lispyclouds

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"iter"
	"net/http"
	"sync"
	"time"

lispyclouds

from dataclasses import dataclass
from typing import Callable, Protocol, Self, TypeVar


T = TypeVar("T", covariant=True)


class Result(Protocol[T]):
    def then(self, f: Callable[[T], Self]) -> Self: ...

lispyclouds

(require '[babashka.deps :as deps])

(deps/add-deps '{:deps {org.babashka/http-client {:mvn/version "0.0.2"}}})

(require '[babashka.http-client :as http]
         '[cheshire.core :as json])

(import '[java.net URL])

(defn get-projects

lispyclouds

#!/usr/bin/env bb

(require '[babashka.process :as p]
         '[clojure.string :as str])

(def authors
  {"rd" {:name  "Rahul De"
         :email "[email protected]"}})

(defn exec

lispyclouds

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.function.Function;

interface Result<T> {
    <R> Result<R> then(Function<T, Result<R>> nextFn);
}

record Success<T>(T value) implements Result<T> {
    @Override

lispyclouds

; JSON Schema
; {
;   "definitions": {
;     "fact": {
;       "type": "object",
;       "properties": {
;         "question":   { "type": "string" },
;         "guess":      { "type": "string" },
;         "no":         { "$ref": "#/definitions/fact" },
;         "wrongGuess": { "$ref": "#/definitions/fact" }

lispyclouds

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

type Result interface {

lispyclouds

#!/usr/bin/env bash

set -eo pipefail

changed=$(git status --porcelain)
is_github_repo=$(git config --get remote.origin.url; echo $?)

declare -A github_users
github_users=(
    ["rd"]="Rahul De <[email protected]>"

lispyclouds

(require '[clojure.java.io :as io]
         '[clojure.string :as s])

(defn line->cmd
  [line]
  ^String
  (some->> (s/index-of line \;)
           inc
           (subs line)))

lispyclouds

import scala.io.StdIn

// Result[+T] is a Monoid with flatMap as the join fn
enum Result[+T] {
  case Success(value: T)
  case Failure(exception: Throwable)

  // bind hence a Monad
  def flatMap[U](f: T => Result[U]) =
    this match {