WELクックブック ​

let raw = {first: '  dana ', last: ' SMITH  '}
do {
  first: raw.first >> trim >> capitalize,
  last: raw.last >> trim >> capitalize,
  full: trim(raw.first) ++ ' ' ++ trim(raw.last) >> titleize
}

let contact = {name: 'Kai', email: null, phone: null}
do {
  name: contact.name,
  email: contact.email | 'no-reply@example.com',
  phone: contact.phone | 'N/A'
}

let api_response = {
  data: {
    users: [
      {profile: {Name: 'Dana'}, orders: [{Name: 'Order-1'}]},
      {profile: {Name: 'Kai'}, orders: [{Name: 'Order-2'}, {Name: 'Order-3'}]}
    ]
  }
}
do deep_collect(api_response, 'Name')

let doc = {
  title: 'Report',
  attachments: [
    {name: 'logo', data: Binary('PNG')},
    {name: 'csv', data: Binary('CSV')}
  ]
}
do deep_map_values_by(
  doc,
  v ~> encode_base64(v),
  v ~> type_of(v) == 'Binary'
)

let orders = [
  {id: 'A1', items: [{sku: 'X', qty: 2}, {sku: 'Y', qty: 1}]},
  {id: 'A2', items: [{sku: 'Z', qty: 5}]}
]
do orders
  >> map_by(o ~> o.items >> map_by(i ~> {order_id: o.id, sku: i.sku, qty: i.qty}))
  >> flatten

let lines = [
  {sku: 'X', qty: 2}, {sku: 'Y', qty: 1},
  {sku: 'X', qty: 3}, {sku: 'Y', qty: 4}
]
do lines
  >> group_by(l ~> l.sku)
  >> entries
  >> map_by(e ~> {sku: e.key, total: e.value >> map_by(row ~> row.qty) >> sum})

let events = [
  {id: 'a', ts: 1, status: 'pending'},
  {id: 'b', ts: 2, status: 'active'},
  {id: 'a', ts: 3, status: 'active'}
]
do events
  >> group_by(e ~> e.id)
  >> values
  >> map_by(group ~> group >> sort_by(e ~> e.ts) >> last)

let rows = [
  {metric: 'cpu', value: 72},
  {metric: 'mem', value: 85},
  {metric: 'disk', value: 40}
]
do rows
  >> map_by(r ~> {key: r.metric, value: r.value})
  >> from_entries

let results = [
  {id: 1, status: 'ok'}, {id: 2, status: 'error'},
  {id: 3, status: 'ok'}, {id: 4, status: 'error'}
]
do let parts = partition_by(results, r ~> r.status == 'ok')
do {
  succeeded: parts[0] >> map_by(r ~> r.id),
  failed: parts[1] >> map_by(r ~> r.id)
}

let users = [{id: 1, name: 'Dana'}, {id: 2, name: 'Kai'}],
    orders = [{user_id: 1, item: 'Book'}, {user_id: 1, item: 'Pen'}, {user_id: 3, item: 'Tape'}]
do users
  >> map_by(u ~> orders
      >> filter_by(o ~> o.user_id == u.id)
      >> map_by(o ~> {name: u.name, item: o.item}))
  >> flatten

let users = [{id: 1, name: 'Dana'}, {id: 2, name: 'Kai'}],
    orders = [{user_id: 1, item: 'Book'}]
do users
  >> map_by(u ~>
      let matches = orders >> filter_by(o ~> o.user_id == u.id)
      do if length(matches) > 0
         then matches >> map_by(o ~> {name: u.name, item: o.item})
         else [{name: u.name, item: null}])
  >> flatten

let crm = [{id: '1', name: 'Dana', source: 'crm'}, {id: '2', name: 'Kai', source: 'crm'}],
    erp = [{id: '2', name: 'Lucian', source: 'erp'}, {id: '3', name: 'Sasha', source: 'erp'}]
do let all_ids = (crm ++ erp) >> map_by(r ~> r.id) >> unique
do all_ids >> map_by(id ~>
    let from_crm = crm >> find_by(r ~> r.id == id),
        from_erp = erp >> find_by(r ~> r.id == id)
    do {
      id: id,
      name: if from_crm != null then from_crm.name else from_erp.name,
      in_crm: from_crm != null,
      in_erp: from_erp != null
    })

let invoice = {amount: Decimal('1234.56'), rate: Decimal('0.85')}
do let converted = invoice.amount * invoice.rate
do {
  original: invoice.amount,
  eur: round_places(converted, 2),
  label: String(round_places(converted, 2)) ++ ' EUR'
}

let json = '{"tx_id": 9999999999999999999, "balance": 1234567890.1234567890}'
do let data = parse_json(json, {decimal: true})
do {
  tx_id: data.tx_id,
  balance: data.balance,
  balance_type: type_of(data.balance),
  cents: data.balance * 100
}

let event_date = PlainDate('2025-03-15')
do let dow = day_of_week(event_date)
do let month_end = end_of_month(event_date)
do {
  is_weekend: dow == 6 or dow == 7,
  days_until_month_end: month_end - event_date,
  quarter: ceil(month(event_date) / 3.0)
}

let payload = '{"amount": "42.50", "currency": "USD"}'
do let data = parse_json(payload)
do let amount = Decimal(data.amount)
guard amount > 0 else 'amount must be positive'
do {amount: amount, currency: data.currency}

let responses = [
  {code: 200, body: 'ok'},
  {code: 422, body: 'validation failed'},
  {code: 200, body: 'ok'},
  {code: 500, body: 'internal error'}
]
do let failures = responses >> filter_by(r ~> r.code >= 400)
do {
  total: length(responses),
  failed: length(failures),
  errors: failures >> map_by(r ~> String(r.code) ++ ': ' ++ r.body)
}

let raw = ['dana@co.com', 'bad-email', '  KAI@CO.COM  ', '', 'sasha@co.com']
do raw
  >> map_by(e ~> trim(e) >> lower)
  >> filter_by(e ~> not blank?(e))
  >> filter_by(e ~> valid_email?(e))

let payload = {items: [{price: 10, qty: 2}, {price: 25, qty: 1}], tax_rate: '0.08'}
do let tax = Decimal(payload.tax_rate)
guard tax >= 0 and tax < 1 else 'invalid tax rate'
do let subtotal = payload.items >> map_by(i ~> i.price * i.qty) >> sum
do {
  subtotal: subtotal,
  tax: round_places(Decimal(subtotal) * tax, 2),
  total: round_places(Decimal(subtotal) * (1 + tax), 2)
}

let inputs = ['42', 'bad', '100', '', '7.5']
do inputs >> map_by(v ~> {
  raw: v,
  parsed: Integer(v) |? null,
  ok: (Integer(v) |? null) != null
})

let search = "O'Brien & Sons"
do "SELECT Id, Name FROM Account WHERE Name = '" ++ escape_for_soql(search) ++ "'"

SELECT Id, Name FROM Account WHERE Name = 'O\'Brien & Sons'

let records = [
  {name: 'Dana', email: 'dana@co.com', amount: 100},
  {name: 'Kai, Jr.', email: 'kai@co.com', amount: 250}
]
do let header = 'Name,Email,Amount'
do let rows = records
    >> map_by(r ~> escape_for_csv(r.name) ++ ',' ++ r.email ++ ',' ++ String(r.amount))
do [header] ++ rows >> join_to_string('\n')

Name,Email,Amount
Dana,dana@co.com,100
"Kai, Jr.",kai@co.com,250

let issued_at = now() >> to_epoch >> floor,
    key = '0123456789abcdef0123456789abcdef'
do let payload = {sub: 'service-account', iat: issued_at, exp: issued_at + 3600}
do let token = jwt_encode(payload, key, 'HS256')
do {
  authorization: 'Bearer ' ++ token,
  decoded: jwt_decode(token, key, 'HS256')
}

{
  authorization: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  decoded: {header: {alg: "HS256", typ: "JWT"}, payload: {sub: "service-account", iat: ..., exp: ...}}
}

let items = ['alpha', 'beta', 'gamma', 'delta']
do items
  >> map_with_index_by((item, i) ~> String(i + 1) ++ '. ' ++ upper(item))
  >> join_to_string('\n')

1. ALPHA
2. BETA
3. GAMMA
4. DELTA

let src = {name: 'Dana', nickname: '', age: 30, internal_id: 'x-123'}
do {
  name: src.name,
  nickname: if not blank?(src.nickname) then src.nickname else Skip(),
  age: src.age,
  internal_id: Skip()
}

fun mask = s ~>
  if length(s) > 4
  then substring(s, 0, 2) ++ '***' ++ substring(s, length(s) - 2, 2)
  else '****'
do let records = [{name: 'Dana', ssn: '123-45-6789'}, {name: 'Kai', ssn: '987-65-4321'}]
do records >> map_by(r ~> {name: r.name, ssn: mask(r.ssn)})