frausto 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6f5347160a2abe4136e948b171065dbab0d4b2816d57dc3d341a7b039c3717b
-  data.tar.gz: fe523a91e6cc71d3de0a42fc592c1ccd21337b67d2aa2355f1da85b7428f06a8
+  metadata.gz: '093f5e9746f4614c8b4085708ccd9b2bf092d06c3a50f5ff08fec837a86ff978'
+  data.tar.gz: 4f1262a4cf6d6e9357f9315729b9628b123034c5092867b9a48f78850acef31f
 SHA512:
-  metadata.gz: 162fe8eb9540ee3d3ca709b8ddf5554bd58bfae2188af5e74d1b9505113d29cc31cee58482d9cbf53b38cd3f4ae6d1d4dde31108862d08a552e42767131000cc
-  data.tar.gz: c16fb85269cf137f8d55443b9e1337b56d20f46de9cd0d816bf3b24c41faa5abd343b6b648d84f27a0eea2f326223b746ea4042dcaad201717fbad703bf2dff4
+  metadata.gz: f2b150ac6dfedb611dd4e924b0497f6c9170122593401d13eff0e8771effc241f3512227fd592d2df6f49278c870015c6c3b7221fd9010e035a1635a4bf1464b
+  data.tar.gz: 7bffe90c34b3ba5a7576044fe6d2f5c0768dbffdf893ded31fb10bfb9425e57b99e1028fb2e5c37ee4eb2d6d5c28c70672b06c76cc19916a0f42a39f6f14e6f9

data/README.md

@@ -30,24 +30,18 @@ gem 'frausto'
 require 'ruby2faust'
 
 code = Ruby2Faust.generate do
-  freq = 60.midi >> smoo
-  -6.db * ((osc(freq) + 0.1 * noise) >> lp(2000))
+  freq = hslider("freq", init: 48, min: 20, max: 100, step: 1) >> midi2hz >> smoo
+  amp = hslider("amp", init: -12, min: -60, max: 0, step: 1) >> db2linear >> smoo
+  osc(freq) >> lp(2000) >> gain(amp)
 end
 
 puts code
-# => import("stdfaust.lib");
-#    process = os.osc(ba.midikey2hz(60) : si.smoo) + (no.noise : *(0.1)) : fi.lowpass(1, 2000) : *(ba.db2linear(-6));
-
-# Use pretty: true for readable output
-puts Ruby2Faust.generate(pretty: true) { -6.db * ((osc(60.midi >> smoo) + 0.1 * noise) >> lp(2000)) }
-# => import("stdfaust.lib");
-#    process =
-#      os.osc(
-#        ba.midikey2hz(60)
-#        : si.smoo
-#      ) + (no.noise : *(0.1))
-#      : fi.lowpass(1, 2000)
-#      : *(ba.db2linear(-6));
+# import("stdfaust.lib");
+#
+# process =
+#   os.osc(hslider("freq", 48, 20, 100, 1) : ba.midikey2hz : si.smoo)
+#   : fi.lowpass(1, 2000)
+#   : *(hslider("amp", -12, -60, 0, 1) : ba.db2linear : si.smoo);
 ```
 
 ```ruby

data/bin/faust2ruby

@@ -18,7 +18,7 @@ parser = OptionParser.new do |opts|
   opts.separator ""
   opts.separator "Options:"
 
-  opts.on("-o", "--output FILE", "Output Ruby file (default: stdout)") do |file|
+  opts.on("-o", "--output FILE", "Output Ruby file (default: <input>.rb)") do |file|
     options[:output] = file
   end
 
@@ -74,6 +74,8 @@ else
   end
   source = File.read(input_path)
   input_name = input_path
+  # Default output to input.dsp.rb (unless expression-only mode or explicit -o)
+  options[:output] ||= "#{input_path}.rb" unless options[:expression_only]
 end
 
 begin

data/faust2ruby.md

@@ -4,8 +4,6 @@ Convert Faust DSP code to Ruby DSL code compatible with ruby2faust.
 
 ## Installation
 
-faust2ruby is included with the frausto gem:
-
 ```bash
 gem install frausto
 ```
@@ -15,29 +13,19 @@ gem install frausto
 ### Command Line
 
 ```bash
-# Convert a Faust file to Ruby
-faust2ruby input.dsp -o output.rb
+# Convert a Faust file to Ruby (writes to file.dsp.rb)
+faust2ruby file.dsp
+
+# Specify output file
+faust2ruby file.dsp -o other.rb
 
-# Output only the process expression (no boilerplate)
-faust2ruby -e input.dsp
+# Output only the process expression (no boilerplate, to stdout)
+faust2ruby -e file.dsp
 
 # Read from stdin
 echo 'process = os.osc(440) : *(0.5);' | faust2ruby -e
 ```
 
-### Options
-
-```
-Usage: faust2ruby [options] <input.dsp>
-  -o, --output FILE    Output Ruby file (default: stdout)
-  -e, --expression     Output only process expression (no boilerplate)
-  -v, --verbose        Verbose output (show parsing info)
-  -t, --tokens         Show lexer tokens (debug mode)
-  -a, --ast            Show AST (debug mode)
-  --version            Show version
-  -h, --help           Show help
-```
-
 ### Ruby API
 
 ```ruby
@@ -46,106 +34,67 @@ require 'faust2ruby'
 # Convert Faust to Ruby code
 faust_code = 'process = os.osc(440) : *(0.5);'
 ruby_code = Faust2Ruby.to_ruby(faust_code)
-puts ruby_code
 
 # Expression only
 ruby_expr = Faust2Ruby.to_ruby(faust_code, expression_only: true)
-# => "(osc(440) >> gain(0.5))"
-
-# Parse to AST
-program = Faust2Ruby.parse(faust_code)
-
-# Tokenize
-tokens = Faust2Ruby.tokenize(faust_code)
+# => "0.5 * osc(440)"
 ```
 
 ## Examples
 
 ### Simple Oscillator
 
-**Input (Faust):**
 ```faust
 process = os.osc(440) : *(0.5);
 ```
-
-**Output (Ruby):**
 ```ruby
-require 'ruby2faust'
-include Ruby2Faust::DSL
-
-process = (osc(440) >> gain(0.5))
-
-puts Ruby2Faust::Emitter.program(process)
+0.5 * osc(440)
 ```
 
 ### Synthesizer with Controls
 
-**Input (Faust):**
 ```faust
 import("stdfaust.lib");
-declare name "synth";
-
 freq = hslider("freq", 440, 20, 20000, 1);
-gain = hslider("gain", 0.5, 0, 1, 0.01);
-
-process = os.osc(freq) : *(gain);
+amp = hslider("amp", 0.5, 0, 1, 0.01);
+process = os.osc(freq) : *(amp);
 ```
-
-**Output (Ruby):**
 ```ruby
-require 'ruby2faust'
-include Ruby2Faust::DSL
-
-# declare name "synth"
-
-freq = slider("freq", init: 440, min: 20, max: 20000, step: 1)
-
-gain = slider("gain", init: 0.5, min: 0, max: 1, step: 0.01)
-
-process = (osc(freq) >> gain(gain))
-
-puts Ruby2Faust::Emitter.program(process)
+freq = hslider("freq", init: 440, min: 20, max: 20000, step: 1)
+amp = hslider("amp", init: 0.5, min: 0, max: 1, step: 0.01)
+process = amp * osc(freq)
 ```
 
-### Parallel Composition
+### Stereo Output
 
-**Input (Faust):**
 ```faust
 process = os.osc(440) , os.osc(880);
 ```
-
-**Output (Ruby):**
 ```ruby
-(osc(440) | osc(880))
+osc(440) | osc(880)
 ```
 
-### Feedback Loop
+### Feedback Delay
 
-**Input (Faust):**
 ```faust
 process = _ ~ (de.delay(44100, 22050) : *(0.5));
 ```
-
-**Output (Ruby):**
 ```ruby
-(wire ~ (delay(44100, 22050) >> gain(0.5)))
+wire ~ (0.5 * delay(44100, 22050))
 ```
 
 ### Iteration
 
-**Input (Faust):**
 ```faust
 process = par(i, 4, os.osc(i * 100));
 ```
-
-**Output (Ruby):**
 ```ruby
-fpar(4) { |i| osc((i * 100)) }
+fpar(4) { |i| osc(i * 100) }
 ```
 
-## Supported Faust Constructs
+## Mapping Overview
 
-### Composition Operators
+### Composition
 
 | Faust | Ruby |
 |-------|------|
@@ -154,88 +103,27 @@ fpar(4) { |i| osc((i * 100)) }
 | `a <: b` | `a.split(b)` |
 | `a :> b` | `a.merge(b)` |
 | `a ~ b` | `a ~ b` |
+| `*(x)` | `x *` (idiomatic) or `gain(x)` |
 
-### Arithmetic
+### Numeric Extensions
 
-| Faust | Ruby |
-|-------|------|
-| `a + b` | `a + b` |
-| `a - b` | `a - b` |
-| `a * b` | `a * b` |
-| `a / b` | `a / b` |
-| `a % b` | `a % b` |
-| `*(x)` | `gain(x)` |
-
-### Comparison
+When arguments are numeric literals, faust2ruby emits idiomatic Ruby:
 
 | Faust | Ruby |
 |-------|------|
-| `a < b` | `a < b` |
-| `a > b` | `a > b` |
-| `a <= b` | `a <= b` |
-| `a >= b` | `a >= b` |
-| `a == b` | `a.eq(b)` |
-| `a != b` | `a.neq(b)` |
-
-Note: `eq()` and `neq()` are methods because Ruby's `==` must return boolean.
-
-### Bitwise
-
-| Faust | Ruby |
-|-------|------|
-| `a & b` | `a & b` |
-| `a \| b` (bitwise) | `a.bor(b)` |
-| `xor(a, b)` | `a ^ b` |
-
-Note: `bor()` is a method because `\|` is used for parallel composition in the DSL.
+| `ba.db2linear(-6)` | `-6.db` |
+| `ba.midikey2hz(60)` | `60.midi` |
+| `ba.sec2samp(0.1)` | `0.1.sec` |
 
 ### Library Functions
 
-| Faust | Ruby |
-|-------|------|
-| `os.osc(f)` | `osc(f)` |
-| `os.sawtooth(f)` | `saw(f)` |
-| `os.square(f)` | `square(f)` |
-| `os.triangle(f)` | `triangle(f)` |
-| `no.noise` | `noise` |
-| `fi.lowpass(n, f)` | `lp(f, order: n)` |
-| `fi.highpass(n, f)` | `hp(f, order: n)` |
-| `fi.resonlp(f, q, g)` | `resonlp(f, q, g)` |
-| `de.delay(m, d)` | `delay(m, d)` |
-| `de.fdelay(m, d)` | `fdelay(m, d)` |
-| `en.adsr(a,d,s,r,g)` | `adsr(a, d, s, r, g)` |
-| `ba.db2linear(x)` | `db2linear(x)` |
-| `si.smoo` | `smoo` |
-| `sp.panner(p)` | `panner(p)` |
-
-### UI Elements
-
-| Faust | Ruby |
-|-------|------|
-| `hslider("n", i, mn, mx, s)` | `slider("n", init: i, min: mn, max: mx, step: s)` |
-| `vslider(...)` | `vslider(...)` |
-| `nentry(...)` | `nentry(...)` |
-| `button("n")` | `button("n")` |
-| `checkbox("n")` | `checkbox("n")` |
-| `hgroup("n", e)` | `hgroup("n") { e }` |
-| `vgroup("n", e)` | `vgroup("n") { e }` |
+Most `os.*`, `fi.*`, `de.*`, `en.*`, `ba.*`, `si.*`, `re.*`, `co.*`, `sp.*`, `aa.*`, `an.*`, `ef.*` functions are mapped. Examples:
 
-### Iteration
-
-| Faust | Ruby |
-|-------|------|
-| `par(i, n, e)` | `fpar(n) { \|i\| e }` |
-| `seq(i, n, e)` | `fseq(n) { \|i\| e }` |
-| `sum(i, n, e)` | `fsum(n) { \|i\| e }` |
-| `prod(i, n, e)` | `fprod(n) { \|i\| e }` |
-
-### Tables
-
-| Faust | Ruby |
-|-------|------|
-| `waveform{v1, v2, ...}` | `waveform(v1, v2, ...)` |
-| `rdtable(n, i, r)` | `rdtable(n, i, r)` |
-| `rwtable(n, i, w, s, r)` | `rwtable(n, i, w, s, r)` |
+- `os.osc(f)` → `osc(f)`
+- `fi.lowpass(n, f)` → `lp(f, order: n)`
+- `de.delay(m, d)` → `delay(m, d)`
+- `en.adsr(a,d,s,r,g)` → `adsr(a, d, s, r, g)`
+- `si.smoo` → `smoo`
 
 ### Primitives
 
@@ -245,164 +133,43 @@ Note: `bor()` is a method because `\|` is used for parallel composition in the D
 | `!` | `cut` |
 | `mem` | `mem` |
 | `ma.SR` | `sr` |
-| `ma.PI` | `pi` |
 
 ## Round-trip Conversion
 
-faust2ruby is designed to work with ruby2faust for round-trip conversion:
-
 ```ruby
-require 'faust2ruby'
-require 'ruby2faust'
+require 'frausto'
 
-# Faust → Ruby
+# Faust → Ruby → Faust
 faust_input = 'process = os.osc(440) : *(0.5);'
-ruby_code = Faust2Ruby.to_ruby(faust_input, expression_only: true)
+ruby_expr = Faust2Ruby.to_ruby(faust_input, expression_only: true)
 
-# Ruby → Faust
 include Ruby2Faust::DSL
-process = eval(ruby_code)
+process = eval(ruby_expr)
 faust_output = Ruby2Faust::Emitter.program(process)
 ```
 
-## With Clauses
+## Advanced Features
 
-`with` clauses are converted to Ruby lambdas for proper scoping:
+### With Clauses
+
+Local definitions are converted to Ruby lambdas:
 
-**Input (Faust):**
 ```faust
-myDSP = result with {
+myDSP = _ * gain with {
     gain = 0.5;
-    result = _ * gain;
 };
 ```
-
-**Output (Ruby):**
 ```ruby
 myDSP = -> {
   gain = 0.5
-  result = (wire * gain)
-  result
+  (wire * gain)
 }.call
 ```
 
-Function-style local definitions use `flambda`:
-```ruby
-adaa = flambda(:x0, :x1) { |x0, x1| select2(...) }
-```
-
-## Partial Application
-
-Faust's partial application creates reusable signal processors by providing some arguments upfront.
-
-### Clipping / Limiting
-
-**Input (Faust):**
-```faust
-// Clip signal to [-1, 1] range
-safetyLimit = min(1) : max(-1);
-process = osc(440) : safetyLimit;
-```
-
-**Output (Ruby):**
-```ruby
-safetyLimit = (flambda(:x) { |x| min_(x, 1) } >> flambda(:x) { |x| max_(x, (-1)) })
-process = (osc(440) >> safetyLimit)
-```
-
-### Conditional Routing
-
-**Input (Faust):**
-```faust
-// Switch between two signals based on condition
-useWet = checkbox("wet");
-effect = _ <: _, reverb : select2(useWet);
-```
-
-**Output (Ruby):**
-```ruby
-useWet = checkbox("wet")
-effect = wire.split(wire, reverb) >> flambda(:x, :y) { |x, y| select2(useWet, x, y) }
-```
-
-### Gain Stages
-
-**Input (Faust):**
-```faust
-// Partial application of multiplication
-halfGain = *(0.5);
-quarterGain = *(0.25);
-process = osc(440) : halfGain;
-```
-
-**Output (Ruby):**
-```ruby
-halfGain = gain(0.5)
-quarterGain = gain(0.25)
-process = (osc(440) >> halfGain)
-```
-
-### Filter Configuration
-
-**Input (Faust):**
-```faust
-// Second-order lowpass waiting for cutoff frequency
-smoothFilter = fi.lowpass(2);
-process = _ : smoothFilter(1000);
-```
-
-**Output (Ruby):**
-```ruby
-smoothFilter = flambda(:x) { |x| lp(x, order: 2) }
-process = (wire >> smoothFilter.call(1000))  # Note: needs .call in Ruby
-```
-
-### Math Functions as Processors
-
-**Input (Faust):**
-```faust
-// 0-arg functions applied to signals
-softclip(x) = tanh(x);
-process = osc(440) * 2 : softclip;
-```
-
-**Output (Ruby):**
-```ruby
-def softclip(x)
-  (x >> tanh_)
-end
-process = ((osc(440) * 2) >> softclip(wire))
-```
-
-## What Uses `literal()`
-
-Some Faust constructs are emitted as `literal()` calls to preserve semantics:
-
-| Construct | Example | Reason |
-|-----------|---------|--------|
-| Letrec blocks | `letrec { 'x = ... }` | Complex state semantics |
-| Unmapped library functions | `an.amp_follower(t)` | Not in library mapper |
-| Partial app (4+ args) | `route(4, 4, ...)` | Requires complex curry |
-
-Most common Faust library functions are mapped, including `fi.*`, `os.*`, `de.*`, `en.*`, `ba.*`, `si.*`, `aa.*`, and math primitives.
-
-## Limitations
-
-**Supported with limitations:**
-- `with` clauses: Local definitions work, scoped via Ruby lambda
-- Partial application: Works for 1-3 missing arguments
-- Forward references: Functions defined later in `with` blocks are resolved
-
-**Not supported:**
-- Pattern matching on function arguments (see below)
-- Foreign functions (`ffunction`)
-- Component/library imports beyond path tracking
-
 ### Case Expressions
 
-Case expressions with integer patterns are converted to `select2` chains:
+Faust's `case` creates a pattern-matching function—the `(n)` pattern binds the input signal to variable `n`:
 
-**Input (Faust):**
 ```faust
 process = case {
   (0) => 1;
@@ -410,114 +177,35 @@ process = case {
   (n) => n * 2;
 };
 ```
-
-**Output (Ruby):**
 ```ruby
-flambda(:n) { |n| select2(n.eq(0), select2(n.eq(1), (n * 2), 2), 1) }
+fcase(0 => 1, 1 => 2) { |n| (n * 2) }
 ```
 
-The variable pattern `(n)` becomes the default/else case, and integer patterns are checked in order.
-
-**Limitations:**
-- Only integer patterns are converted to `select2` (variable patterns become default)
-- Complex patterns (tuples, nested expressions) fall back to `literal()`
-- Recursive functions like `fact(0) = 1; fact(n) = n * fact(n-1)` require compile-time evaluation not available at runtime
+The `fcase` DSL method handles integer patterns as a hash, with the block as the default case.
 
-### Pattern Matching on Function Arguments
+### Partial Application
 
-Multi-rule function definitions with single-parameter pattern matching are now supported:
-
-**Input (Faust):**
 ```faust
-fact(0) = 1;
-fact(n) = n * fact(n - 1);
+halfGain = *(0.5);
+process = osc(440) : halfGain;
 ```
-
-**Output (Ruby):**
 ```ruby
-fact = flambda(:n) { |n| select2(n.eq(0), (n * fact((n - 1))), 1) }
+halfGain = gain(0.5)
+process = osc(440) >> halfGain
 ```
 
-Multiple definitions with the same name are automatically merged into a case expression, then converted to `select2` chains.
-
-**Limitations:**
-- Only single-parameter pattern matching is supported
-- Multi-parameter patterns (e.g., `foo(0, 0) = a; foo(x, y) = b;`) are not merged
-- Recursive functions like factorial require compile-time evaluation (the Ruby output is syntactically correct but may not produce the same runtime behavior)
-
-## Known Issues
-
-### letrec Blocks
-
-`letrec` blocks are emitted as `literal()` calls because they implement complex recursive state semantics that don't have a direct Ruby DSL equivalent.
-
-**Example Faust:**
-```faust
-// Spring-damper physics simulation
-follower(input) = pos letrec {
-    'v = v + step * (-damping * v - stiffness * (pos - input));
-    'pos = pos + step * v;
-};
-```
+## Limitations
 
-**Generated Ruby:**
-```ruby
-literal("letrec { 'v = (v + (step * ...)); 'pos = (pos + (step * v)) } pos")
-```
+**Not fully supported:**
+- `letrec` blocks (emitted as `literal()`)
+- Foreign functions (`ffunction`)
+- Multi-parameter pattern matching
+- Some library namespaces: `ve.*`, `pm.*`, `sy.*`, `dx.*`
 
-**Why this happens:**
-- `'v` means "next value of v" (sample n+1)
-- `v` means "current value of v" (sample n)
-- This creates mutually recursive signals with feedback
-- Ruby lacks native syntax for this pattern
-
-**Workarounds:**
-1. **Accept the literal** - Round-trip conversion still works; the Faust code is preserved
-2. **Use simple feedback** - For single-variable recursion, use `wire ~ expr` instead
-3. **Refactor in Faust** - Sometimes letrec can be rewritten using standard feedback
-
-**Impact:** In practice, letrec is rare. Complex DSP files like triode.lib (500+ lines) convert with only 1 literal remaining (the letrec block).
-
-### Unmapped Library Functions
-
-The following Faust library namespaces are not yet mapped and will emit `literal()`:
-
-| Namespace | Description | Status |
-|-----------|-------------|--------|
-| `ve.*` | Virtual analog (Moog filters, etc.) | Not mapped |
-| `pm.*` | Physical modeling | Not mapped |
-| `sy.*` | Synthesizers | Not mapped |
-| `dx.*` | DX7 emulation | Not mapped |
-| `pf.*` | Phaflangers | Not mapped |
-| `dm.*` | Demos | Not mapped |
-
-**Currently mapped:**
-- `os.*` - Oscillators (osc, saw, square, triangle, phasor, lf_*)
-- `no.*` - Noise (noise, pink_noise)
-- `fi.*` - Filters (lowpass, highpass, resonlp, svf.*, allpass, dcblocker, peak_eq, tf1/tf2, etc.)
-- `de.*` - Delays (delay, fdelay, sdelay)
-- `en.*` - Envelopes (ar, asr, adsr, adsre)
-- `ba.*` - Basics (db2linear, linear2db, tau2pole, midikey2hz, selectn, if, take)
-- `si.*` - Signals (smooth, smoo, bus, block)
-- `ma.*` - Math (SR, PI, tempo, tanh)
-- `re.*` - Reverbs (mono_freeverb, zita_rev1_stereo, jpverb)
-- `co.*` - Compressors (compressor_mono, limiter_1176_R4_mono)
-- `sp.*` - Spatial (panner)
-- `aa.*` - Antialiasing (tanh1, tanh2, arctan, softclip, hardclip, etc.)
-- `an.*` - Analyzers (amp_follower, amp_follower_ar, rms_envelope_*, abs_envelope_*, peak_envelope)
-- `ef.*` - Effects (gate_mono/stereo, flanger_mono/stereo, phaser2_mono/stereo, wah4, auto_wah, crybaby, echo, transpose, vocoder, speakerbp, cubicnl, dryWetMixer)
-- Math primitives (sin, cos, tan, tanh, sinh, cosh, abs, min, max, pow, sqrt, exp, log, floor, ceil, etc.)
-
-**Contributing:** To add support for unmapped functions, edit `lib/faust2ruby/library_mapper.rb` and add corresponding entries to `lib/ruby2faust/ir.rb`, `lib/ruby2faust/dsl.rb`, and `lib/ruby2faust/emitter.rb`.
+Unmapped functions are preserved as `literal("...")` for round-trip compatibility.
 
 ## Architecture
 
 ```
 Faust Source → Lexer → Parser → AST → Ruby Generator → Ruby DSL
 ```
-
-- **Lexer** (`lexer.rb`): StringScanner-based tokenizer
-- **Parser** (`parser.rb`): Recursive descent parser
-- **AST** (`ast.rb`): Abstract syntax tree nodes
-- **Generator** (`ruby_generator.rb`): Produces Ruby DSL code
-- **Library Mapper** (`library_mapper.rb`): Maps Faust functions to Ruby methods

data/lib/faust2ruby/ruby_generator.rb

@@ -29,6 +29,9 @@ module Faust2Ruby
       imports = program.statements.select { |s| s.is_a?(AST::Import) }.map(&:path)
       declares = program.statements.select { |s| s.is_a?(AST::Declare) }
 
+      # Standard Faust output names
+      output_names = %w[process effect]
+
       unless @expression_only
         lines << "require 'ruby2faust'"
         lines << "include Ruby2Faust::DSL"
@@ -41,26 +44,28 @@ module Faust2Ruby
 
         lines << "" if declares.any?
 
-        # Generate helper definitions (excluding process)
+        # Generate helper definitions (excluding outputs)
         merged_statements.each do |stmt|
-          if stmt.is_a?(AST::Definition) && stmt.name != "process"
+          if stmt.is_a?(AST::Definition) && !output_names.include?(stmt.name)
             lines << generate_definition(stmt)
             lines << ""
           end
         end
       end
 
-      # Generate process
-      process_def = @definitions["process"]
-      if process_def
+      # Find the main output (process or effect)
+      output_name = output_names.find { |name| @definitions[name] }
+      output_def = @definitions[output_name] if output_name
+
+      if output_def
         if @expression_only
-          lines << generate_expression(process_def.expression)
+          lines << generate_expression(output_def.expression)
         else
-          lines << "process = #{generate_expression(process_def.expression)}"
+          lines << "#{output_name} = #{generate_expression(output_def.expression)}"
           lines << ""
 
           # Build program with imports and declares
-          lines << "prog = Ruby2Faust::Program.new(process)"
+          lines << "prog = Ruby2Faust::Program.new(#{output_name})"
           imports.each do |imp|
             lines << "  .import(#{imp.inspect})" unless imp == "stdfaust.lib"
           end
@@ -68,7 +73,7 @@ module Faust2Ruby
             lines << "  .declare(:#{d.key}, #{d.value.inspect})"
           end
           lines << ""
-          lines << "puts Ruby2Faust::Emitter.program(prog)"
+          lines << "puts Ruby2Faust::Emitter.program(prog, output: #{output_name.inspect})"
         end
       end
 
@@ -531,7 +536,7 @@ module Faust2Ruby
         min = generate_expression(node.min)
         max = generate_expression(node.max)
         step = generate_expression(node.step)
-        "slider(#{node.label.inspect}, init: #{init}, min: #{min}, max: #{max}, step: #{step})"
+        "hslider(#{node.label.inspect}, init: #{init}, min: #{min}, max: #{max}, step: #{step})"
 
       when :vslider
         init = generate_expression(node.init)
@@ -677,7 +682,7 @@ module Faust2Ruby
 
     # Generate code for case expressions
     # case { (0) => a; (1) => b; (n) => c; }
-    # converts to: flambda(:x) { |x| select2(x.eq(0), select2(x.eq(1), c, b), a) }
+    # converts to: fcase(0 => a, 1 => b) { |n| c }
     def generate_case_expr(node)
       branches = node.branches
 
@@ -706,29 +711,23 @@ module Faust2Ruby
         return generate_case_literal(node)
       end
 
-      # Generate a flambda that takes the input and uses select2 chains
-      # We need to use the variable name from default branch if present, else use 'x'
-      var = default_branch ? default_branch[:var] : "x"
-      var = ruby_safe_param(var)
+      # Get variable name from default branch if present, else use 'x'
+      var = default_branch ? ruby_safe_param(default_branch[:var]) : "x"
+
+      # Build the fcase pattern hash
+      patterns = int_branches.map do |branch|
+        "#{branch[:value]} => #{generate_expression(branch[:result])}"
+      end.join(", ")
 
-      # Build the select2 chain from inside out
-      # Start with the default/else case (or the last integer branch result if no default)
+      # Build default expression
       if default_branch
-        inner = generate_expression(default_branch[:result])
+        default_expr = generate_expression(default_branch[:result])
       else
-        # No default - use the last branch result as fallback (arbitrary choice)
-        inner = generate_expression(int_branches.last[:result])
-        int_branches = int_branches[0...-1]
-      end
-
-      # Wrap each integer pattern with select2
-      # select2(cond, false_val, true_val) - condition true returns second arg
-      int_branches.reverse_each do |branch|
-        result = generate_expression(branch[:result])
-        inner = "select2(#{var}.eq(#{branch[:value]}), #{inner}, #{result})"
+        # No default - use 0 as fallback
+        default_expr = "0"
       end
 
-      "flambda(:#{var}) { |#{var}| #{inner} }"
+      "fcase(#{patterns}) { |#{var}| #{default_expr} }"
     end
 
     # Fall back to literal for complex case expressions

data/lib/ruby2faust/dsl.rb

@@ -732,34 +732,60 @@ module Ruby2Faust
     # CONVERSION (ba.)
     # =========================================================================
 
-    def db2linear(x)
-      x = to_dsp(x)
-      DSP.new(Node.new(type: NodeType::DB2LINEAR, inputs: [x.node]))
+    def db2linear(x = nil)
+      if x.nil?
+        DSP.new(Node.new(type: NodeType::DB2LINEAR, inputs: []))
+      else
+        x = to_dsp(x)
+        DSP.new(Node.new(type: NodeType::DB2LINEAR, inputs: [x.node]))
+      end
     end
+    alias db2lin db2linear
 
-    def linear2db(x)
-      x = to_dsp(x)
-      DSP.new(Node.new(type: NodeType::LINEAR2DB, inputs: [x.node]))
+    def linear2db(x = nil)
+      if x.nil?
+        DSP.new(Node.new(type: NodeType::LINEAR2DB, inputs: []))
+      else
+        x = to_dsp(x)
+        DSP.new(Node.new(type: NodeType::LINEAR2DB, inputs: [x.node]))
+      end
     end
+    alias lin2db linear2db
 
-    def samp2sec(x)
-      x = to_dsp(x)
-      DSP.new(Node.new(type: NodeType::SAMP2SEC, inputs: [x.node]))
+    def samp2sec(x = nil)
+      if x.nil?
+        DSP.new(Node.new(type: NodeType::SAMP2SEC, inputs: []))
+      else
+        x = to_dsp(x)
+        DSP.new(Node.new(type: NodeType::SAMP2SEC, inputs: [x.node]))
+      end
     end
 
-    def sec2samp(x)
-      x = to_dsp(x)
-      DSP.new(Node.new(type: NodeType::SEC2SAMP, inputs: [x.node]))
+    def sec2samp(x = nil)
+      if x.nil?
+        DSP.new(Node.new(type: NodeType::SEC2SAMP, inputs: []))
+      else
+        x = to_dsp(x)
+        DSP.new(Node.new(type: NodeType::SEC2SAMP, inputs: [x.node]))
+      end
     end
 
-    def midi2hz(x)
-      x = to_dsp(x)
-      DSP.new(Node.new(type: NodeType::MIDI2HZ, inputs: [x.node]))
+    def midi2hz(x = nil)
+      if x.nil?
+        DSP.new(Node.new(type: NodeType::MIDI2HZ, inputs: []))
+      else
+        x = to_dsp(x)
+        DSP.new(Node.new(type: NodeType::MIDI2HZ, inputs: [x.node]))
+      end
     end
 
-    def hz2midi(x)
-      x = to_dsp(x)
-      DSP.new(Node.new(type: NodeType::HZ2MIDI, inputs: [x.node]))
+    def hz2midi(x = nil)
+      if x.nil?
+        DSP.new(Node.new(type: NodeType::HZ2MIDI, inputs: []))
+      else
+        x = to_dsp(x)
+        DSP.new(Node.new(type: NodeType::HZ2MIDI, inputs: [x.node]))
+      end
     end
 
     def tau2pole(tau)
@@ -894,13 +920,15 @@ module Ruby2Faust
       name.to_s.include?("[") ? name.to_s : "#{meta}#{name}"
     end
 
-    def slider(name, init:, min:, max:, step: 0.01, **meta)
+    def hslider(name, init:, min:, max:, step: 0.01, **meta)
       full_name = DSL.build_metadata(name, **meta)
-      DSP.new(Node.new(type: NodeType::SLIDER, args: [full_name, init, min, max, step]))
+      DSP.new(Node.new(type: NodeType::HSLIDER, args: [full_name, init, min, max, step]))
     end
+    alias slider hslider
 
-    def vslider(name, init:, min:, max:, step: 0.01)
-      DSP.new(Node.new(type: NodeType::VSLIDER, args: [name, init, min, max, step]))
+    def vslider(name, init:, min:, max:, step: 0.01, **meta)
+      full_name = DSL.build_metadata(name, **meta)
+      DSP.new(Node.new(type: NodeType::VSLIDER, args: [full_name, init, min, max, step]))
     end
 
     def nentry(name, init:, min:, max:, step: 1)
@@ -1002,6 +1030,30 @@ module Ruby2Faust
       DSP.new(Node.new(type: NodeType::PARAM, args: [name]))
     end
 
+    # Case expression with integer patterns
+    # @param patterns [Hash{Integer => Object}] Integer patterns mapped to results
+    # @yield Block for default case, receives the input variable
+    # @return [DSP]
+    # @example
+    #   fcase(0 => 1, 1 => 2) { |n| n * 2 }
+    #   # generates: case { (0) => 1; (1) => 2; (n) => n * 2; }
+    def fcase(patterns = {}, &block)
+      raise ArgumentError, "fcase requires a block for the default case" unless block_given?
+
+      # Get variable name from block parameter
+      var_name = block.parameters.first&.last || :x
+      var = param(var_name)
+
+      # Evaluate the block to get the default expression
+      default_expr = to_dsp(block.call(var))
+
+      # Convert pattern values to DSP nodes
+      pattern_nodes = patterns.transform_values { |v| to_dsp(v).node }
+
+      # Create CASE node: args = [var_name, patterns_hash, default_expr]
+      DSP.new(Node.new(type: NodeType::CASE, args: [var_name, pattern_nodes, default_expr.node]))
+    end
+
     # =========================================================================
     # TABLES
     # =========================================================================

data/lib/ruby2faust/emitter.rb

@@ -44,7 +44,7 @@ module Ruby2Faust
       my_prec < parent_prec ? "(#{expr})" : expr
     end
 
-    def program(process, imports: nil, declarations: {}, pretty: false)
+    def program(process, imports: nil, declarations: {}, pretty: false, output: "process")
       if process.is_a?(Program)
         node = process.process.is_a?(DSP) ? process.process.node : process.process
         imports ||= process.imports
@@ -59,9 +59,9 @@ module Ruby2Faust
       lines << "" if declarations.any?
       imports.each { |lib| lines << "import(\"#{lib}\");" }
       lines << ""
-      
+
       body = emit(node, pretty: pretty, prec: 0)
-      lines << "process = #{body};"
+      lines << "#{output} = #{body};"
       lines.join("\n") + "\n"
     end
 
@@ -219,23 +219,17 @@ module Ruby2Faust
       when NodeType::MUL
         if node.inputs.count == 2
           left_node, right_node = node.inputs
-          # Normalize: signal : *(scalar) - idiomatic Faust gain (uses SEQ precedence)
-          if scalar?(right_node) && !scalar?(left_node)
-            my_prec = PREC[:seq]
-            left = emit(left_node, indent: indent, pretty: pretty, prec: my_prec)
-            right = emit(right_node, indent: indent, pretty: pretty, prec: PREC[:primary])
-            wrap("#{left} : *(#{right})", my_prec, prec)
-          elsif scalar?(left_node) && !scalar?(right_node)
-            my_prec = PREC[:seq]
-            left = emit(right_node, indent: indent, pretty: pretty, prec: my_prec)
-            right = emit(left_node, indent: indent, pretty: pretty, prec: PREC[:primary])
-            wrap("#{left} : *(#{right})", my_prec, prec)
-          else
-            my_prec = PREC[:mul]
-            left = emit(left_node, indent: indent, pretty: pretty, prec: my_prec)
-            right = emit(right_node, indent: indent, pretty: pretty, prec: my_prec + 1)
-            wrap("#{left} * #{right}", my_prec, prec)
+          # Always emit idiomatic Faust: signal : *(gain)
+          # Normalize scalar-on-left to signal : *(scalar)
+          if scalar?(left_node) && !scalar?(right_node)
+            # Swap: put signal on left
+            left_node, right_node = right_node, left_node
           end
+          my_prec = PREC[:seq]
+          left = emit(left_node, indent: indent, pretty: pretty, prec: my_prec)
+          # Don't require high precedence for gain arg - *(x) already groups it
+          right = emit(right_node, indent: indent, pretty: pretty, prec: 0)
+          wrap("#{left} : *(#{right})", my_prec, prec)
         else
           "*"
         end
@@ -352,17 +346,17 @@ module Ruby2Faust
 
       # === CONVERSION ===
       when NodeType::DB2LINEAR
-        "ba.db2linear(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
+        node.inputs.empty? ? "ba.db2linear" : "ba.db2linear(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
       when NodeType::LINEAR2DB
-        "ba.linear2db(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
+        node.inputs.empty? ? "ba.linear2db" : "ba.linear2db(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
       when NodeType::SAMP2SEC
-        "ba.samp2sec(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
+        node.inputs.empty? ? "ba.samp2sec" : "ba.samp2sec(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
       when NodeType::SEC2SAMP
-        "ba.sec2samp(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
+        node.inputs.empty? ? "ba.sec2samp" : "ba.sec2samp(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
       when NodeType::MIDI2HZ
-        "ba.midikey2hz(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
+        node.inputs.empty? ? "ba.midikey2hz" : "ba.midikey2hz(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
       when NodeType::HZ2MIDI
-        "ba.hz2midikey(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
+        node.inputs.empty? ? "ba.hz2midikey" : "ba.hz2midikey(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
       when NodeType::TAU2POLE
         "ba.tau2pole(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
       when NodeType::POLE2TAU
@@ -424,7 +418,7 @@ module Ruby2Faust
         "sp.panner(#{emit(node.inputs[0], indent: indent, pretty: pretty)})"
 
       # === UI CONTROLS ===
-      when NodeType::SLIDER
+      when NodeType::HSLIDER
         name, init, min, max, step = node.args
         "hslider(\"#{name}\", #{init}, #{min}, #{max}, #{step})"
       when NodeType::VSLIDER
@@ -490,6 +484,14 @@ module Ruby2Faust
         "\\(#{param_str}).(#{emit(body.node, indent: indent, pretty: pretty)})"
       when NodeType::PARAM
         node.args[0].to_s
+      when NodeType::CASE
+        var_name, patterns, default_node = node.args
+        branches = patterns.map do |val, result_node|
+          "(#{val}) => #{emit(result_node, indent: indent, pretty: pretty)}"
+        end
+        default_expr = emit(default_node, indent: indent, pretty: pretty)
+        branches << "(#{var_name}) => #{default_expr}"
+        "case { #{branches.join('; ')}; }"
 
       # === TABLES ===
       when NodeType::RDTABLE

data/lib/ruby2faust/ir.rb

@@ -184,7 +184,7 @@ module Ruby2Faust
     PANNER = :panner  # sp.panner(pan) - stereo pan
 
     # === UI Controls ===
-    SLIDER   = :slider
+    HSLIDER  = :hslider
     VSLIDER  = :vslider
     NENTRY   = :nentry
     BUTTON   = :button
@@ -211,6 +211,7 @@ module Ruby2Faust
     # === Lambda ===
     LAMBDA = :lambda  # \(x).(body)
     PARAM  = :param   # Parameter reference
+    CASE   = :case    # case { (0) => a; (n) => b; }
 
     # === Tables ===
     RDTABLE  = :rdtable   # rdtable(n, init, ridx)

data/lib/ruby2faust/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ruby2Faust
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/lib/ruby2faust.rb

@@ -16,12 +16,17 @@ module Ruby2Faust
   #     osc(440).then(gain(0.3))
   #   end
   #
+  # @example Generate an effect instead of process
+  #   code = Ruby2Faust.generate(output: "effect") do
+  #     wire >> delay(48000, 0.5.sec) * 0.5
+  #   end
+  #
   # @yield Block that returns a DSP
   # @return [String] Faust source code
-  def self.generate(pretty: false, &block)
+  def self.generate(pretty: true, output: "process", &block)
     context = Object.new
     context.extend(DSL)
-    process = context.instance_eval(&block)
-    Emitter.program(process, pretty: pretty)
+    result = context.instance_eval(&block)
+    Emitter.program(result, pretty: pretty, output: output)
   end
 end

data/ruby2faust.md

@@ -7,13 +7,10 @@ A Ruby DSL that generates Faust DSP code. Ruby describes the graph; Faust compil
 ```ruby
 require 'ruby2faust'
 
-# Idiomatic Ruby style
 code = Ruby2Faust.generate do
-  # Use numeric extensions: .midi, .hz, .db
-  freq = 60.midi >> smoo
-  
-  # Arithmetic operators for signal mixing
-  (osc(freq) + noise) * -6.db
+  freq = hslider("freq", init: 48, min: 20, max: 100, step: 1) >> midi2hz >> smoo
+  amp = hslider("amp", init: -12, min: -60, max: 0, step: 1) >> db2linear >> smoo
+  osc(freq) >> lp(2000) >> gain(amp)
 end
 
 puts code
@@ -23,7 +20,10 @@ Output:
 ```faust
 import("stdfaust.lib");
 
-process = ((os.osc(ba.midikey2hz(60)) + no.noise) * ba.db2linear(-6));
+process =
+  os.osc(hslider("freq", 48, 20, 100, 1) : ba.midikey2hz : si.smoo)
+  : fi.lowpass(1, 2000)
+  : *(hslider("amp", -12, -60, 0, 1) : ba.db2linear : si.smoo);
 ```
 
 ## Composition
@@ -146,15 +146,21 @@ floor_, ceil_, rint_
 ```
 
 ### Conversion (ba.)
+
+With argument (wrapping):
 ```ruby
-db2linear(x)   # dB to linear
-linear2db(x)   # Linear to dB
-midi2hz(x)     # MIDI note to Hz
-hz2midi(x)     # Hz to MIDI note
-samp2sec(x)    # Samples to seconds
-sec2samp(x)    # Seconds to samples
+db2linear(-6)  # ba.db2linear(-6)
+midi2hz(60)    # ba.midikey2hz(60)
 ```
 
+Without argument (chainable):
+```ruby
+hslider("amp", ...) >> db2linear >> smoo   # hslider(...) : ba.db2linear : si.smoo
+hslider("freq", ...) >> midi2hz >> smoo    # hslider(...) : ba.midikey2hz : si.smoo
+```
+
+All conversion functions: `db2linear`, `linear2db`, `midi2hz`, `hz2midi`, `samp2sec`, `sec2samp`
+
 ### Smoothing (si.)
 ```ruby
 smooth(tau)    # Smooth with time constant
@@ -185,6 +191,11 @@ fpar(4) { osc((it + 1) * 100) }       # par(it, 4, osc((it+1)*100))
 flambda(:x) { |x| x * 2 }    # \(x).(x * 2)
 ```
 
+### Case (Pattern Matching)
+```ruby
+fcase(0 => 1, 1 => 2) { |n| n * 2 }  # case { (0) => 1; (1) => 2; (n) => n : *(2); }
+```
+
 ### Tables
 ```ruby
 waveform(0, 0.5, 1, 0.5)              # waveform{0, 0.5, 1, 0.5}
@@ -277,11 +288,11 @@ prog = Ruby2Faust::Program.new do
   osc(440) * 0.5
 end
 
-# Generate pretty-printed Faust with indentation and newlines
-puts Ruby2Faust::Emitter.program(prog, pretty: true)
+# Generate Faust (pretty-printed by default)
+puts Ruby2Faust::Emitter.program(prog)
 
-# The generate helper also supports pretty: true
-puts Ruby2Faust.generate(pretty: true) do
+# Use pretty: false for compact single-line output
+puts Ruby2Faust.generate(pretty: false) do
   hgroup("Synth") { osc(440) + noise }
 end
 ```
@@ -290,20 +301,44 @@ end
 
 ```ruby
 require 'ruby2faust'
-include Ruby2Faust::DSL
 
-gate = button("gate")
-freq = slider("freq", init: 220, min: 20, max: 2000, style: :knob) >> smoo
-cutoff = slider("cutoff", init: 1000, min: 100, max: 8000, style: :knob) >> smoo
+code = Ruby2Faust.generate do
+  gate = button("gate")
+  freq = hslider("freq", init: 48, min: 20, max: 100, step: 1) >> midi2hz >> smoo
+  cutoff = hslider("cutoff", init: 2000, min: 100, max: 10000, step: 1) >> smoo
+  res = hslider("res", init: 0.5, min: 0, max: 1, step: 0.01)
+
+  env = adsr(0.01, 0.1, 0.7, 0.3, gate)
+  saw(freq) >> resonlp(cutoff, res, 1) * env
+end
+```
+
+## Example: Feedback Delay
+
+```ruby
+require 'ruby2faust'
+
+code = Ruby2Faust.generate do
+  dtime = hslider("delay", init: 0.3, min: 0.01, max: 1, step: 0.01) >> sec2samp >> smoo
+  fback = hslider("feedback", init: 0.5, min: 0, max: 0.95, step: 0.01) >> smoo
+  wet = hslider("wet", init: 0.5, min: 0, max: 1, step: 0.01) >> smoo
+
+  wire.feedback(delay(48000, dtime) * fback) * wet
+end
+```
 
-env = adsr(0.01, 0.2, 0.6, 0.3, gate)
+## Example: Stereo Panner
 
-process = saw(freq) >> resonlp(cutoff, 4, 1) >> gain(env) >> panner(0.5)
+```ruby
+require 'ruby2faust'
 
-prog = Ruby2Faust::Program.new(process)
-  .declare(:name, "SubSynth")
+code = Ruby2Faust.generate do
+  freq = hslider("freq", init: 48, min: 20, max: 100, step: 1) >> midi2hz >> smoo
+  pan = hslider("pan", init: 0.5, min: 0, max: 1, step: 0.01) >> smoo
+  amp = hslider("amp", init: -12, min: -60, max: 0, step: 1) >> db2linear >> smoo
 
-puts Ruby2Faust::Emitter.program(prog)
+  osc(freq) * amp >> panner(pan)
+end
 ```
 
 ## CLI

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: frausto
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - David Lowenfels
 bindir: bin
 cert_chain: []
-date: 2026-01-21 00:00:00.000000000 Z
+date: 2026-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest