cleanup, patterns

js-fp3/library/logging.d.ts

@@ -9,6 +9,17 @@ export declare const outputWith: <T>(
 
 export declare const outputError: <E>(src: string, error: E) => void;
 
+export declare const logSuccess: <T, E>(src: string, message: string) => (
+  result: import('./result.js').Result<T, E>
+) => import('./result.js').Result<T, E>;
+
+export declare const logSuccessWith: <T, E>(
+  src: string,
+  renderText: (x: T) => string
+) => (result: import('./result.js').Result<T, E>) => import('./result.js').Result<T, E>;
+
+export declare const formatMoney: (money: { amount: number }) => string;
+
 export declare const log: <T, E>(src: string, message: string) => (
   result: import('./result.js').Result<T, E>
 ) => import('./result.js').Result<T, E>;

js-fp3/library/logging.js

@@ -1,4 +1,7 @@
-import { tap, tapError } from './result.js';
+import { tap, tapError, pipe } from './result.js';
+import { formatMoney as formatMoneyFromDomain } from '../domain/money.js';
+
+export { formatMoneyFromDomain as formatMoney };
 
 export const logReturn = (message, r) => {
   console.log(message);
@@ -19,6 +22,12 @@ export const outputError = (src, error) => {
   console.error(`\x1b[1;31m[${src} ERROR]\x1b[0m ${value}`);
 };
 
-export const log = (src, message) => tap(output(src, message));
+export const logSuccess = (src, message) => tap(output(src, message));
 
-export const logWith = (src, renderText) => tap(outputWith(src, renderText));
+export const logSuccessWith = (src, renderText) => tap(outputWith(src, renderText));
+
+export const log = (src, message) => (result) =>
+  pipe(result, tap(output(src, message)), tapError((e) => outputError(src, e)));
+
+export const logWith = (src, renderText) => (result) =>
+  pipe(result, tap((x) => output(src, renderText(x))(x)), tapError((e) => outputError(src, e)));

js-fp3/library/patterns.d.ts

@@ -0,0 +1,9 @@
+export type Predicate<T> = (value: T) => boolean;
+export type Handler<T, R> = (value: T) => R;
+export type Branch<T, R> = [Predicate<T>, Handler<T, R>];
+
+export declare const match: <T, R>(...branches: Branch<T, R>[]) => (value: T) => R;
+
+export declare const when: <T, R>(predicate: Predicate<T>, handler: Handler<T, R>) => Branch<T, R>;
+
+export declare const any: Predicate<any>;

js-fp3/library/patterns.js

@@ -0,0 +1,10 @@
+export const match = (...branches) => (value) => {
+  for (const [predicate, handler] of branches) {
+    if (predicate(value)) return handler(value);
+  }
+  throw new Error('No matching pattern');
+};
+
+export const when = (predicate, handler) => [predicate, handler];
+
+export const any = () => true;