# Syntax
What Powscript Bash output
Functions 
        
foo(a b)
  echo a=$a b=$b
        
        
foo one two
        
      
        
f() {
local a="${1}" b="${2}"
echo a="${a}" b="${b}"
}
        
        
foo one two
Switch statement 
        
switch $foo
  case [0-9]*
    echo "bar"
  case *
    echo "foo"
        
      
        
case "${foo}" in
  [0-9]*)
    echo "bar"
    ;;
  *)
    echo "foo"
    ;;
esac
Easy if statements 
        
if $i is "foo"
  echo "foo"
else
  echo "bar"


if not false and true
  if true or false
    echo "foo"
        
        
if $x > $y
  echo "bar"
elif $a < $b
  echo "baz"

      
        
if [[ "$i" == "foo" ]]; then
  echo "foo"
else
  echo "bar"
fi
        
        
if ! false && true; then
  if true || false; then
    echo 10
  fi
fi
        
        
if [[ "$x" -gt "$y" ]]; then
  echo "bar"
elif [[ "$a" -lt "$b" ]]; then
  echo "baz"
fi
Associative arrays 
        
foo={}
foo["bar"]="a value"
        
        
for k,v of foo
  echo k=$k
  echo v=$v
        
        
echo $foo["bar"]
        
      
        
declare -A foo
foo["bar"]="a value"
        
        
for k in "${!foo[@]}"; do
  v="${foo[$k]}"
  echo k="$k"
  echo v="$v"
done
        
        
echo "${foo["bar"]}"
Indexed array 
        
bla=[]
bla[0]="foo"
bla@="push value"
        
        
for i of bla
  echo bla=$i
        
        
echo $bla[0]
        
      
        
declare -a bla
bla[0]="foo"
bla[${#bla}]="push value"
        
        
for i in "${bla[@]}"; do
  echo bla="$i"
done
        
        
echo "${bla[0]}"
Read file line by line (shared scope) 
        
for line from $selfpath/foo.txt
  echo "->"$line
        
      
        
  while IFS="" read -r line; do
    echo "->"$line
  done < $1
Regex 
        
if $f match ^([f]oo)
  echo "foo found!"
        
      
        
# extended pattern matching
# (google 'extglob' for more)
        
        
if [[ "$f" =~ ^([f]oo) ]]; then
  echo "foo found!"
fi
Requiring modules 
        
# compile and include
# powscript file
require 'mymodule.pow'
        
        
# source works at runtime
source foo.bash
empty / isset checks 
        
bar()
  if empty $1
    echo "no argument given"
  if isset $1
    echo "string given"
        
        
foo "$@"
        
      
        
foo(){
  if [ -z "${1}" ]; then
    echo "no argument given"
  fi
  if [ -n "${#1}" ]; then
    echo "string given"
  fi
}
        
        
foo "$@"
mappipe unwraps a pipe 
        
fn()
  echo "value=$1"
        
        
echo -e "a\nb\n" | mappipe fn
        
      
        
# outputs: value=a
#          value=b
Easy math 
        
math (9 / 2)
math (9 / 2) 4
        
      
        
# outputs: '4' and '4.5000'
# NOTE: floating point math
#       requires bc
Easy async 
        
fn()
  sleep 1s
  echo "one"
        
        
await fn 123 then
  echo "async done"
        
      
        
# outputs: one
#          async done
Easy async pipe 
        
fn()
  sleep 1s
  echo "one"
        
        
await fn 123 then |
  cat -
when done
  echo "async done"
        
      
        
# outputs: one
#          async done
Easy async pipe (per line) 
        
fn()
  sleep 1s
  echo "one"
  echo "two"
        
        
await fn 123 then for line
  echo "line: $*"
when done
  echo "async done"
        
      
        
# outputs: line: one
#          line: two
#          async done
JSON parsing 
        
obj={}
json='{"a": {"b": "c"}}'
        
        
json_parse obj "$json"
json_print obj a b
        
      
        
# outputs: c
FP: curry 
        
fn(a b)
  echo "1=$a 2=$b"
        
        
curry fnc a
echo -e "b\nc\n" | mappipe fnc
        
      
        
# outputs: 1=a 2=b
#          1=a 2=c
FP: array values, keys 
        
foo={}
foo["one"]="foo"
foo["two"]="bar"
map foo keys
map foo values
        
      
        
# outputs: one
#          two
#          foo
#          bar
FP: map 
        
printitem(k v)
  echo "key=$k value=$v"
        
        
foo={}
foo["one"]="foo"
foo["two"]="bar"
map foo printitem
FP: pick 
        
foo={}
bar={}
foo["one"]="foo"
bar["foo"]="123"
map foo values |\
  mappipe pick bar
        
      
        
# outputs: 123
FP: compose 
        
fnA(x)
  echo "($x)"
        
        
fnB(x)
  echo "|$x|"
        
        
compose decorate fnA fnB
decorate "foo"
        
      
        
# outputs: (|foo|)
# Predefined vars | **description** | **variable name** | **example** | |---------------------------|-------------------|------------------------------------| | script path | $selfpath | for line in $selfpath/foo.txt | | current working directory | $self | ls $self/* | | temporary file | $tmpfile | echo '{foo:"bar"}' > $tmpfile.json |