Forem: Kazuki Okamoto

Envar — Centrally manage environment variables to switch per directory

Kazuki Okamoto — Tue, 04 Nov 2025 05:35:43 +0000

I've created a command-line tool called Envar.

kakkun61 / envar

This is a command-line tool that automatically switches values of environment variables based on the current directory path.

envar

This is a command-line tool that automatically switches values of environment variables based on the current directory path.

Place the envar binary
Install the shell hook
Write the configuration file

Place the `envar` binary

Run go build and place the binary file in your PATH.

Install the shell hook

Add this line to your .bashrc:

eval "$(envar hook)"

and add this line to your .bash_logout:

envar hook logout $$

Write the configuration file

The configuration file uses YAML. It is located at $CONFIG_DIR/envar/vars.yaml and $CONFIG_DIR/envar/execs.yaml. $CONFIG_DIR is the value returned by os.UserConfigDir().

vars.yaml is used to define environment variable values. For example:

FOO_VAR:
  path/to/dir: foo-value-1
  other/path: foo-value-2
  other/path/never: foo-value-3
  # This is a comment line
  ~/projects: foo-value-4
  "spacial dir/path": foo-value-5
BAR_VAR:
  another/dir: bar-value-1

The directory path/to/dir…

View on GitHub

This is a tool that allows switching environment variable values on a per-directory basis.

For example, you can configure an environment variable named FOO to return the value hoge when in the directory path/to/A, and fuga when in the directory path/to/B. This configuration is specified in a vars.yaml file like this:

FOO:
  path/to/A: hoge
  path/to/B: fuga

You can also configure environment variables to derive their values from the output of other commands.

This example is excerpted from my own configuration files and demonstrates switching between personal and work accounts when using the gh command.

# vars.yaml
GH_TOKEN:
  /home/kazuki/Projects/Work:
    gh: kakkun61_work
  /home/kazuki/Projects:
    gh: kakkun61

# execs.yaml
gh: gh auth token --user %s

Frequently Asked Questions Maybe

What's the difference between this and direnv?

Direnv works by writing configuration files containing environment variables you want to set in that directory, primarily for environment variables needed by all users of a project. These are project-specific environment variables.

In contrast, envar stores configuration files in the user-specific settings directory (e.g., ~/.config/envar). It's designed for setting environment variables that serve personal needs, such as account switching in the above example.

Which shell versions are supported?

Currently, only bash is supported. If there's demand, I may add support for zsh as well.

Mainly translated by Plamo Translation.

wd command

Kazuki Okamoto — Tue, 18 Oct 2022 18:12:45 +0000

I have just released wd command!

What's wd command?

A following command runs a COMMAND with some OPTIONS on a DIRECTORY as a working directory.

$ wd DIRECTORY COMMAND OPTIONS

pushd and popd are too long to type for me.

Install

Binaries are provided at a GitHub Release page. They are for Windows, Linux, and macOS (x64)¹.

https://github.com/kakkun61/wd/releases/tag/0.1.0.0

If you want to build it, you need cabal and ghc.

$ make install

You like it? Give a star on the GitHub repo.

I'm going to add a binary for macOS (ARM) when GitHub Actions will provide a macOS (ARM) platform. ↩

Path Environment Variable Quick Switcher for PowerShell

Kazuki Okamoto — Mon, 23 Aug 2021 11:17:21 +0000

You may want to turn on and off the PATH environment variable, for example, when you use UNIX tools with MSYS2.

It's annoying like this.

» $prevPath = $Env:Path
» $Env:Path = "$Env:MSYS2\bin;$Env:MSYS2\mingw64\bin;$Env:Path"
» # do some work with MSYS2
» $Env:Path = $prevPath

Or you may want to change each version of compilers.

powershell-path-switcher supports this.

kakkun61 / powershell-path-switcher

Path Environment Variable Quick Switcher

powershell-path-switcher

Path Environment Variable Quick Switcher.

JFyT6Gn0gm2n2m60.mp4

Install

Invoke the following commands to install this.

> Install-Module path-switcher
> Import-Module path-switcher

HEAD

If you want to use HEAD, follow this instruction.

> git clone git@github.com:kakkun61/powershell-path-switcher.git
> Import-Module .\powershell-path-switcher\path-switcher.psd1 # -Force option may be necessary

Configuration

This module treats three types of configurations:

local configuration
user global configuration
system global configuration

Local configuration

A local configuration is named powershell-path-switcher.yaml and located at the current working directory or its parents recursively.

User global configuration

A user global configuration is named config.yaml and located at $Env:APPDATA\powershell-path-switcher.

System global configuration

A system global configuration is named config.yaml and located at $Env:ProgramData\powershell-path-switcher.

Overwriting

When the configurations have the same keys, upper ones overwrite.

For example there are following configurations:

# local configuration
foo:

…

View on GitHub

PowerShell Gallery

Interactive select

A quick view is at this video.

Prepare a configuration file,

# $Env:ProgramData\powershell-path-switcher\config.yaml
msys2-usr:     C:\tools\msys64\usr\bin
msys2-mingw64: C:\tools\msys64\mingw64\bin

and invoke Switch-Path.

» Switch-Path
> [ ] msys2-usr: C:\tools\msys64\usr\bin
  [ ] msys2-mingw64: C:\tools\msys64\mingw64\bin

You can move its cursor (>) up/down with ↑/↓ keys, select (check by x) with the space key and reflect with the enter key.

When you want to remove a specified path from the PATH variable, you can delete it by removing its check mark (x).

For more information see a README.

Ephemeral Purely Functional Data Structure and Linear Type: Again

Kazuki Okamoto — Fri, 01 Jan 2021 09:52:10 +0000

The Japanese version is at はてなブログ.

Additional information for the previous article.

Ephemeral Purely Functional Data Structure and Linear Type

Kazuki Okamoto ・ Dec 28 '20

#haskell

No loopholes using `pure`

Meh, there is a loophole to escape from the constraint with pure.

I wrote it carelessly, I was noticed good information on Reddit.

I think the solution to the problem with empty might be to use the Ur (for "unrestricted") datatype from linear-base:
empty :: (Queue a #-> Ur b) #-> Ur b
Trying to run empty Ur shouldn't typecheck, because the Ur constructor is not linear. This seems to be an idiom used in other places of linear-base.

Queue a cannot get escaped because of making the type of the return value Ur b. Passing Queue a to Ur is not allowed because the parameter of Ur :: a -> Ur a may be used many times. How smart!

No need for CPS

I found that functions other than generators (empty in this case) are no need for CPS.

When applying a linear arrow to a value that is a parameter of another linear arrow, it seems that its return value has linearity too. I must check typing rules about this.

// Detect dark theme var iframe = document.getElementById('tweet-1340894183578431489-237'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1340894183578431489&theme=dark" }

In other words, It is not necessary to make enqueue etc. CPS because their return values must be used once when applying them in a continuation Queue a #-> Ur b of empty.

null :: Queue a #-> (Ur Bool, Queue a)
null (Queue l m) = (Ur (P.null l), Queue l m)

enqueue :: a -> Queue a #-> Queue a
enqueue a (Queue l m) = check l (a:m)

dequeue :: Queue a #-> (Ur (Maybe a), Queue a)
dequeue (Queue (a:l) m) = (Ur (Just a), check l m)
dequeue (Queue l m) = (Ur Nothing, Queue l m)

That being so, user codes are as the following. It was easy to write/read if the “let” expression could be used.

  it "empty → enqueue → dequeue" $ do
    let
      f :: Queue Int #-> Ur Int
      f q =
        enqueue 0 q PL.& \q ->
        dequeue q PL.& \(Ur (Just a), q) ->
        q `lseq` Ur a
      Ur a = empty f
    a `shouldBe` 0

Ephemeral Purely Functional Data Structure and Linear Type

Kazuki Okamoto — Mon, 28 Dec 2020 16:13:39 +0000

The Japanese version is at はてなブログ.

Chapter 5.2 of “Purely Functional Data Structures” (PFDS) explains an ephemeral purely functional queue.

This queue has a constraint that you can operate just once for each value because of its computational complexity. For example, the first following operations are accepted, but the second may take a long time.

-- a good example
ops =
  let
    q0 = empty
    q1 = enqueue 0 q0
    q2 = enqueue 1 q1
    Just (a, _) = dequeue q2
  in
    a

-- a bad example
ops =
  let
    q0 = empty
    q1 = enqueue 0 q0
    q2 = enqueue 1 q1
    q2' = enqueue 2 q1 -- q1 is used twice
    Just (a, _) = dequeue q2
    Just (b, _) = dequeue q2'
  in
    (a, b)

The theme of this article is that linear types can save this constraint.

Used versions

GHC 9.0.1 alpha 1 (9.0.0.20200925)
- A linear arrow is (#->), not (%1 ->)
linear-base 341007891ae77959ac7b147f008e3a1d9c46e96b

Implementation

I implemented it with the continuation-passing style (CPS) because the GHC adopts linear arrows as linear types. For instance, empty has the following type.

empty :: (Queue a #-> b) #-> b

Its continuation has Queue a #-> b type and so a value of Queue a type is used only once in this function.

I implemented others too. Please refer to the PFDS for these computational complexities.

{-# LANGUAGE GADTs #-}
{-# LANGUAGE LinearTypes #-}
{-# LANGUAGE Strict #-}

data Queue a where
  Queue :: [a] -> [a] -> Queue a
  deriving (Show)

empty :: (Queue a #-> b) #-> b
empty k = k (Queue [] [])

null :: Queue a #-> ((Bool, Queue a) #-> b) #-> b
null (Queue l m) k = k (P.null l, Queue l m)

enqueue :: a -> Queue a #-> (Queue a #-> b) #-> b
enqueue a (Queue l m) k = k (check l (a:m))

dequeue :: Queue a #-> (Maybe (a, Queue a) #-> b) #-> b
dequeue (Queue (a:l) m) k = k (Just (a, check l m))
dequeue (Queue _ _) k = k Nothing

check :: [a] -> [a] -> Queue a
check [] m = Queue (reverse m) []
check l m = Queue l m

The reason for using GADT is to implement functions like null. If not using GADT, the linearity was required for l and m of Queue l m recursively and so l cannot be used twice.

This implementation has one inconvenient stuff, that values of Queue a type cannot be removed, because linear types request exactly one use. They must get to be return values. Therefore I made Queue a be an instance of the Consumable type class of the Prelude.Linear module of the linear-base package.

instance Consumable a => Consumable (Queue a) where
  consume (Queue l m) = l `lseq` m `lseq` ()

Now I will try to use this.

> import Prelude.Linear (lseq)
> import Data.Queue.Ephemeral
> empty (\q0 -> enqueue 0 q0 (\q1 -> dequeue q1 (\(Just (a, q2)) -> q2 `lseq` a))) :: Int
0

… Ah, yeah, It can be used. It can just be used, it cannot be used comfortably.

Continuation monad

You can use “do” notation to write/read it easily because CPS functions are monad instances.

Now can linear CPS functions be linear monad instances? Let me try. … (three days after) They can be! The following type can be a linear monad instance. It was more difficult than I expected to type validly because I was not familiar with linear types.

newtype ContT r m a = ContT { runContT :: (a #-> m r) #-> m r }

I will try to use it.

> :set -XQualifiedDo
> import Prelude.Linear (lseq)
> import qualified Prelude.Linear as PL
> import Data.Queue.Ephemeral
> import Control.Monad.Trans.Cont.Linear
> import qualified Control.Monad.Linear as ML
> :{
| PL.flip runCont PL.id $ ML.do
|   q0 <- cont empty
|   q1 <- cont (enqueue (0 :: Int) q0)
|   Just (a, q2) <- cont (dequeue q1)
|   q2 `lseq` ML.pure a
| :}
0

Yahoo!

Meh, there is a loophole to escape from the constraint with pure.

Repository

https://github.com/kakkun61/ephemeral-linear-data/tree/fd2f936ffea1a8d98445947dea460234217286b1

Additional article

Ephemeral Purely Functional Data Structure and Linear Type: Again

Kazuki Okamoto ・ Jan 1 '21

#haskell

Static site generator powered by Shake, Lucid, and Hint

Kazuki Okamoto — Sun, 27 Sep 2020 05:53:04 +0000

The Japanese version is at はてなブログ.

I have a website for self-published books (Doujin-shi; 同人誌), which was generated by Jekyll. I replaced it with a generator powered by Shake, Lucid, and Hint.

The source codes are in this repository. And I made a template repository.

Why

I chose Jekyll naturally because I chose GitHub Pages as a host. When I followed the rail, Jekyll was useful. However, when I wanted to do out of the rail, Jekyll got to be hard to be used.

I will explain what the website is before an explanation of what I wanted to do. This website introduces my self-published books and consists of pages of each book and a page of a list of books. Every book has information on sales and exhibitions (Sokubaikai; 即売会) because the books are distributed in ones. And I wanted to show which books are distributed on a sale and exhibition. In other words, I wanted pages of each sale and exhibition and a page of a list of ones. This was difficult with Jekyll (at least with a version of that time).

I made the site on about January 2018, and soon I intended to change its framework. I tried Hakyll but I didn't like its API design and I didn't change it for a time.

A day I found Shake, which is used by the GHC project as a build system. I thought it may be useful for my site too. And I found two static website generators using Shake which are Rib and Slick.

I preferred Slick's API and tried to use it. After I removed unnecessary parts of Slick for me, I found no need for Slick and used Shake directly.

Project structure

Following is a figure of its project structure.

First I didn't want compilations with GHC and links each time contents are changed because they take a long time. And so I decided to embed a Haskell interpreter with a Hint package.

This is a flow of a generation: writing a rule of a build with Shake, embedding an interpreter with Hint, and building executable gen. By executing gen, reading Haskell source codes of contents and images, etc., converting them, and outputting them as HTML, etc.

Data.hs is read by both because it is used for generating of gen and by the interpreter executed by gen.

There are two styles of Shake's rule. One is “backward” style like Make from products to sources, the other is “forward” one from sources to products. This time I used forward style. The forward style needs Filesystem Access Tracer (fsatrace).

Implementation

A directory structure is like this.

app
- gen.hs — a generator itself
content
- book/xxx.hs — a page of a book
- image
- lib/Layout.hs — layouts wrapping contents
- style
- xxx.hs — other pages
lib
- Data.hs — data types for both gen.hs and book/xxx.hs
doujin-site.cabal

A point of gen is about this.

lucid :: forall p r. (Show p, Typeable r) => FilePath -> FilePath -> p -> Shake.Action r
lucid source destination param = do
  libs <- Shake.getDirectoryFiles "content/lib" ["*.hs"]
  result <- liftIO $ Hint.runInterpreter $ do
    Hint.set [Hint.languageExtensions := [Hint.DuplicateRecordFields, Hint.OverloadedStrings]]
    Hint.loadModules $ ("content" </> source) : (("content/lib" </>) <$> libs)
    Hint.setTopLevelModules ["Main"]
    Hint.setImports ["Data.Functor.Identity", "Lucid", "Data.Text"]
    Hint.interpret ("render (" ++ show param ++ ")") (Hint.as :: Lucid.Html r)
  case result of
    Left e  -> do
      liftIO $ hPutStrLn stderr $ displayException e
      fail "interpret"
    Right html -> do
      Shake.writeFile' ("out" </> destination) $ show html
      pure $ runIdentity $ Lucid.evalHtmlT html

I think this is not very difficult. There is one constraint which is that show param should output a valid Haskell code. When it is derived automatically it must be no problem but manual implementations of show may not work.

Haskell source codes of contents must expose render :: Typeable r => p -> Html r. book/xxx.hs is like bellow.

{-# LANGUAGE OverloadedStrings #-}

import           Data
import qualified Layout as L

import Lucid

render path = do
  L.top (L.ogp ogp) $ L.book book (Just content)
  pure book
  where
    ogp = …
    book = …
    content = …

The Book return values of each page are gathered and passed to index.hs. index.hs uses it for making a list of books.

{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns        #-}
{-# LANGUAGE OverloadedStrings     #-}

import           Data
import qualified Layout as L

import Data.Foldable as F
import Lucid

render (path, books) =
  L.top
    (L.ogp ogp)
    $ div_ [class_ "home"] $ do
        ul_ [class_ "book-list"] $ do
          F.for_ books $ \(Book { title, bookImage, events }, path) -> do
            li_ $ do
              h3_ $
                a_ [class_ "post-link", href_ path] $ toHtml title
              div_ [class_ "justify-bottom"] $ do
                ul_ [class_ "event-badges"] $ do
                  F.for_ events $ \Event { title } -> do
                    li_ [class_ "event-badge"] $ toHtml title
                    " "
                a_ [href_ path] $ img_ [src_ bookImage, alt_ "book image", class_ "home-book-front"]
  where
    ogp = …

I chose Lucid as an HTML notation. A unified syntax is easy because Lucid is an embedded DSL. You can change this part if you want.

After these preparations, I think it is easy to make pages of sales and exhibitions and a page of a list of them.

Summary

Shake as a dependencies resolver
Hint for embedding an interpreter
- Compilation of contents is unnecessary
Lucid as an HTML notation
- EDSL produces a unified syntax

In my opinion, I have noticed again that I prefer combining libraries as parts to making content for frameworks because the former is more flexible.

The Simplest MonadFail Instance

Kazuki Okamoto — Wed, 02 Sep 2020 10:28:54 +0000

The Japanese version is at はてなブログ.

Introduction

After fail was removed from Monad a long time ago, I prefer to type computations that may fail to MonadFail.

foo :: MonadFail m => m a

This allows you to instantiate m to IO within the IO context, and to instantiate it to Maybe within the pure context for example.

-- within IO context
foo :: IO a

-- within pure context
foo :: Maybe a

It is not happy that Maybe discards the failure messages. So should we use Either? Either is not actually a MonadFail instance. There was a proposal about this which was rejected because of the following reason.

the instances "get in the way of a user who wants to treat the parameter uniformly"

That being so I wanted the following Result type as the simplest MonadFail instance.

newtype Result a = Result (Either String a)

instance MonadFail Result where
  fail = Left

There is actually an equivalent of this but it is deprecated. It is ErrorT of the mtl package.

either-result package

I released the either-result package which contains Result and some functions.

https://hackage.haskell.org/package/either-result

Actually Result is an alias of ResultT Identity and ResultT is a newtype of ExceptT of the transformers package.

type Result a = ResultT Identity a

newtype ResultT m a = ResultT (ExceptT String m a)

What is the difference between ResultT and ExceptT is about MonadFail instances. On ResultT fail wraps a message with Left, while on ExceptT it calls fail of its base monad. Because of it, on ResultT its base monad is requested to be just Monad, but on ExceptT its one is requested to be MonadFail.

instance Monad m => MonadFail (ResultT m) where …

instance MonadFail m => MonadFail (ExceptT e m) where …

You can use throwError and catchError because ResultT is also MonadError instance of the mtl package.

What about the exceptions package?

There is MonadThrow type class, isn't it? Yes, the exceptions package has MonadThrow and MonadCatch type classes. These requests something thrown and caught to be Exception instances. In my opinion, if you want to recognise thrown and caught things by their type, you should use them. And if you want just messages, use MonadFail.

class Monad m => MonadThrow m where
  throwM :: Exception e => e -> m a

class MonadThrow m => MonadCatch m where
  catch :: Exception e => m a -> (e -> m a) -> m a

class Monad m => MonadFail m where
  fail :: String -> m a

Conclusion

on defining, type computations which may fail to MonadFail m => m a
on using, use it as IO a within IO context for example
on using, use it as Result a within a pure context
add star to the GitHub repository 😉

Forem: Kazuki Okamoto

Envar — Centrally manage environment variables to switch per directory

kakkun61 / envar

This is a command-line tool that automatically switches values of environment variables based on the current directory path.

envar

Place the envar binary

Install the shell hook

Write the configuration file

Frequently Asked Questions Maybe

wd command

What's wd command?

Install

Path Environment Variable Quick Switcher for PowerShell

kakkun61 / powershell-path-switcher

Path Environment Variable Quick Switcher

powershell-path-switcher

Install

HEAD

Configuration

Local configuration

User global configuration

System global configuration

Overwriting

Interactive select

Ephemeral Purely Functional Data Structure and Linear Type: Again

Ephemeral Purely Functional Data Structure and Linear Type

Kazuki Okamoto ・ Dec 28 '20

No loopholes using pure

No need for CPS

Ephemeral Purely Functional Data Structure and Linear Type

Used versions

Implementation

Continuation monad

Repository

Additional article

Ephemeral Purely Functional Data Structure and Linear Type: Again

Kazuki Okamoto ・ Jan 1 '21

Static site generator powered by Shake, Lucid, and Hint

Why

Project structure

Implementation

Summary

The Simplest MonadFail Instance

Introduction

either-result package

What about the exceptions package?

Conclusion

Place the `envar` binary

No loopholes using `pure`