# POSIX: Parse text, hope format doesn't change
ps aux | grep 'nu' | awk '{print $2, $11}'
 
# Nushell: Query structured data directly
ps | where name =~ 'nu' | select pid name

# Variables (immutable by default)
let name = "value"
mut counter = 0
$counter += 1
 
# String interpolation
$"Hello ($name), count: ($counter)"
 
# Pipeline input variable
"text" | { $in | str upcase }    # $in holds pipeline input
 
# Conditionals
if $condition { ... } else { ... }
 
# Loops
for item in $list { ... }
while $condition { ... }
 
# Pattern matching
match $value {
    "a" => { ... }
    "b" | "c" => { ... }
    _ => { ... }
}
 
# Closures
{|x| $x * 2 }
 
# Custom commands with typed parameters
def greet [name: string, --loud (-l)] {
    if $loud { $name | str upcase } else { $name }
}

# Input (source): generates data
ls                              # Produces table of files
 
# Filter: transforms data
| where size > 1mb              # Keep rows matching condition
| select name size              # Choose columns
| sort-by size --reverse        # Order by column
 
# Output (sink): consumes data
| first 5                       # Take top 5
| save large-files.json         # Write to file (or display)

ls **/*.rs                    # Recursive glob (no find needed!)
cd ~/projects
open file.json                # Auto-parses by extension
save output.json              # Saves structured data

where condition               # Filter rows
select col1 col2              # Choose columns
get column                    # Extract as list (not table)
sort-by column                # Sort
group-by column               # Aggregate
each {|x| transform $x}       # Transform items
update col { new_value }      # Modify column

lines                         # Split text into lines
split row ","                 # Split string
parse "{name}: {value}"       # Extract with pattern
from json / to json           # Format conversion

# External commands run automatically, output captured as text
git status
 
# Use ^ to force external version (bypass internal command)
^ls -la                       # System ls, not Nushell ls
 
# Capture stdout, stderr, and exit_code with complete
let result = (git push | complete)
if $result.exit_code != 0 {
    print $"Error: ($result.stderr)"
}
 
# Parse external output into structured data
docker ps --format json | from json

# Try/catch
try {
    risky-operation
} catch {|e|
    print $"Error: ($e.msg)"
}
 
# Optional chaining (safe navigation)
$record.field?                # Returns null if missing
$record | get -i field        # Same with command

# ✗ WRONG - treats $in as first parameter
def my-func [list: list, value: any] {
    $list | append $value
}
 
# ✓ CORRECT - declares pipeline signature
def my-func [value: any]: list -> list {
    $in | append $value
}
 
# Usage
[1 2 3] | my-func 4  # Works correctly

def func [x: int] { ... }                    # params only
def func []: string -> int { ... }           # pipeline only
def func [x: int]: string -> int { ... }     # both

# Row condition - auto expands $it
$table | where size > 100           # Expands to: $it.size > 100
$table | where name =~ "test"
 
# Closure - explicit parameter
$table | where {|row| $row.size > 100}
$list | where {$in > 10}
 
# Closures can be stored and reused
let big_files = {|row| $row.size > 1mb}
ls | where $big_files

nu                           # Interactive shell
nu script.nu                 # Run script
nu -c 'command'              # One-liner