JA(1)

📦 version 3.3.0.6, in nixos 26.05, nixpkgs unstable

💖 ja(1) — Jacinda 💖

okay bestie, this is the manual page for ja — Jacinda: data filtering, processing, reporting. It's giving “AWK but make it a whole vibe,” and I'm here to walk you through every flag and builtin without losing a single crumb. 🫶

🌸 NAME 🌸

ja — Jacinda: data filtering, processing, reporting.

✨ SYNOPSIS ✨

ja run src.jac -i data.txt

cat FILE1 FILE2 | ja '#"$0'

ja tc script.jac

ja e '11.67*1.2'

🦋 DESCRIPTION 🦋

Jacinda is a data stream processing language à la AWK. Literally that's the description, and it's iconic.

💅 SUBCOMMANDS 💅

  • run — run a program from file.
  • tc — typecheck a program.
  • e — evaluate an expression (without reference to a file).

🎀 OPTIONS 🎀

  • -h, --help — display help.
  • -V, --version — display version information.
  • -I, --include — include directory for imports.
  • -F — field separator regex.
  • -R — record separator regex.
  • --csv — process as CSV.
  • -b, --header — include match when splitting records.
  • -Dfile=main.c — define variable.

🧚 LANGUAGE 🧚

🔥 REGEX 🔥

Regular expressions follow Rust’s regex library: https://docs.rs/regex/. no cap, that's the regex lore.

💀 BUILTINS 💀

Okay this is the builtin buffet — every single one, exactly like the source, with the type signatures preserved. ⭐

  • :i — postfix operator: parse integer.
  • :f — postfix operator: parse float.
  • : — postfix operator: parse, inferring type.
  • # — prefix operator: tally (count bytes in string).
  • #* — prefix operator: list length; List a -> a.
  • , — ternary operator: zip with; (a -> b -> c) -> Stream a -> Stream b -> Stream c.
  • | — ternary operator: fold; Foldable f :=> (b -> a -> b) -> b -> f a -> b.
  • |> — fold without seed; Foldable f :=> (a -> a -> a) -> f a -> a.
  • ^ — ternary operator: scan; (b -> a -> b) -> b -> Stream a -> Stream b.
  • ^* — scan (list); (b -> a -> b) -> b -> List a -> List b.
  • ", ¨ — binary operator: map; Functor f :=> a -> b -> f a -> f b.
  • [: — unary operator: const; a -> b -> a.
  • #. — binary operator: filter; Witherable f :=> (a -> Bool) -> f a -> f a.
  • \. — binary operator: prior; (a -> a -> b) -> Stream a -> Stream b.
  • ~. — unary deduplication (stream); Ord a :=> Stream a -> Stream a.
  • ~.* — deduplicate on (stream); Ord b :=> (a -> b) -> Stream a -> Stream a.
  • max — maximum of two values; Ord a :=> a -> a -> a.
  • min — minimum of two values; Ord a :=> a -> a -> a.
  • & — boolean and.
  • || — boolean or.
  • ! — prefix boolean not.
  • ~ — matches regex; Str -> Regex -> Bool.
  • !~ — does not match; Str -> Regex -> Bool.
  • ix, ⍳ — line number.
  • substr — extract substring; Str -> Int -> Int -> Str.
  • sub1 — substitute first occurrence; Regex -> Str -> Str -> Str.
  • subs — substitute all occurrences; Regex -> Str -> Str -> Str.
  • split — split a string by regex; Str -> Regex -> List Str.
  • splitc — split a string on a single character; Str -> Str -> List Str.
  • ⌊, |. — floor function; Float -> Int.
  • Ceiling function — symbols:
⌈, |`

type: Float -> Int.

  • -. — unary negate.
  • sprintf — convert an expression to a string using the format string; %f float, %i integer, %s string, %b boolean.
  • option — option eliminator; b -> (a -> b) -> Option a -> b.
  • match — Str -> Regex -> Option (Int . Int).
  • ~? — maybe match: return string if it is a match, otherwise None; Str -> Regex -> Option Str.
  • ~* — match, returning nth capture group; Str -> Int -> Regex -> Option Str.
  • captures — return all aptures (nth capture group); Str -> Int -> Regex -> List Str.
  • :? — mapMaybe; Witherable f :=> (a -> Option b) -> f a -> f b.
  • .? — catMaybes; Witherable f :=> f (Option a) -> f a.
  • fp — filename.
  • nf — number of fields.
  • ⍬ — empty string/empty list.
  • head#, last# — List a -> a.
  • tail#, init# — List a -> List a.
  • drop#, take# — Int -> List a -> List a.

🦋 SYNTAX 🦋

  • 'str' — string literal.
  • /pat/ — regex literal.
  • `n — nth field.
  • `0 — current line.
  • `* — last field.
  • `$ — all fields; List Str.
  • $n — nth column.
  • $0 — stream of lines.
  • {%<pattern>}{<expr>} — filtered stream on lines matching <pattern>, defined by <expr>.
  • {<expr>}{<expr>} — filtered stream defined by <expr>, on lines satisfying a boolean expression.
  • {|<expr>} — stream defined by <expr>.
  • #t — boolean literal.
  • _n — negative number.
  • .n — extract the nth value; List a -> a.
  • ->n — get the nth element of a tuple.
  • `{. — line comment.
  • @include'/path/file.jac’ — file include.
  • ?<expr>; <expr>; <expr> — if... then... else.
  • <pattern>,,<pattern> <expr> — bookend a stream.
  • <expr> $> <expr> — print stream and summary result.
  • fn f(x, y) := x + y; — function definition.
  • let val x := y + 1 in x end — let binding.
  • (<expr> . <expr> . ... . <expr>) — tuple.
  • #{ <fieldname> .= <expr>; ... <fieldname> .= <expr> } — record literal.

🎀 DECLARATIONS 🎀

  • :set fs=/REGEX/; — set field separator.
  • :set rs=/REGEX/; — set record separator.
  • :set header; — include match when splitting records.
  • :set csv; — process as CSV.
  • :flush; — flush stdout for every line.

🌈 INFLUENTIAL ENVIRONMENT VARIABLES 🌈

  • JAC_PATH — colon-separated list of directories to search for imports.

🍓 EXAMPLES 🍓

  1. Print lines longer than 72 bytes:
[#x>72] #. $0
  1. Print lines longer than 72 bytes:
{#`0>72}{`0}
  1. Select only the third line:
{ix=3}{`0}
  1. Present column names of a .csv file:
:set csv; {ix=1}{[x+'\n'+y]|>`$}
  1. Sum first column:
(+)|0 $1:i
  1. Count lines:
(+)|0 [:1"$0
  1. Count lines:
[y]|> {|ix}
  1. Count bytes (+1 for newlines):
(+)|0 [#x+1]"$0
  1. Count bytes:
(+)|0 {|#`0+1}
  1. Display with line numbers:
{|sprintf '%i: %s' (ix.`0)}
  1. Is the first column strictly increasing?
(&)|#t (>)\. {|`1:f}
  1. Is the last line blank?
[y]|> {|`0~/^$/}
  1. Trim trailing whitespace:
{|option ⍬ [x] (`0 ~* 1 /^((\s+\S|\S)*)\s*$/)}
  1. Concatenate into one line, discarding leading whitespace between:
ja -R'\n\s*' "[x+' '+y]|>\$0"

💀 BUGS 💀

bestie, if you find a bug, please report it to https://github.com/vmchale/jacinda/issues — that's the exact link from the page. 🫶

Copyright 2021-2022. Vanessa McHale. All Rights Reserved.

🌟 AUTHORS 🌟

Vanessa McHalevamchale@gmail.com

okay that's the whole ja(1) page. The footer has no extra source/version or date listed beyond the manual name, so this is the cute sign-off: stay streaming, stay slaying, and may your regexes always be valid. 💖✨🎀

📦 where this page comes from