LoginSignup
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

@kuangzhixitian3

effect-tsでSchemaでテキスト電文で送信先のデータを取得するようなものを考慮する

Posted at

自分のPCからサーバにあるPCに対してメッセージを送信し、サーバのデータを使用してデータを取得できるとよさそうな気がした
書いているうちにanyがめちゃくちゃ多くなってしまった

参考

やりたいこと

クラウドデータに対して、データを取得することを考える

とりたいデータは以下のような感じ

計算式に渡すテキスト電文は以下を想定

ソースコード

import { Chunk, Effect, Either, Exit, ParseResult, Schema, Sink, Stream } from "effect"

// #region --- token ---

const TokenType = Schema.Literal("演算子", "数字", "変数")

const TokenType_演算子 = Schema.Literal("+", "-", "＋", "ー")
const decode_TokenType_演算子 = Schema.decodeUnknownEither(TokenType_演算子)

const TokenType_数字 = Schema.Literal(
  "1",
  "2",
  "3",
  "4",
  "5",
  "6",
  "7",
  "8",
  "9",
  "0",
  "１",
  "２",
  "３",
  "４",
  "５",
  "６",
  "７",
  "８",
  "９",
  "０"
)
const decode_TokenType_数字 = Schema.decodeUnknownEither(TokenType_数字)

function get_TokenType_From_String(text: string) {
  const result_0 = decode_TokenType_演算子(text)
  if (Either.isRight(result_0)) return TokenType.literals["0"]

  const result_1 = decode_TokenType_数字(text)
  if (Either.isRight(result_1)) return TokenType.literals["1"]

  return TokenType.literals["2"]
}

// #endregion

// #region --- token object ---

const OneToken = Schema.Struct({
  character: Schema.String,
  token_type: TokenType
})

const OneToken_From_String = Schema.transform(
  Schema.String,
  OneToken,
  {
    strict: true,
    decode: (text) => ({
      character: text,
      token_type: get_TokenType_From_String(text)
    }),
    encode: (token) => token.character
  }
)
const decode_OneToken = Schema.decodeSync(OneToken_From_String)

// #endregion

// #region --- token object array ---

const TokenArray_From_String = Schema.transform(
  Schema.String,
  Schema.Array(OneToken),
  {
    strict: true,
    decode: (text) =>
      Array.from(text).map((one_text) => {
        const result = decode_OneToken(one_text)
        return result
      }),
    encode: (array) => array.map((token) => token.character).join("")
  }
)
const decode_TokenArray = Schema.decodeSync(TokenArray_From_String)
const encode_TokenArray = Schema.encodeUnknownSync(TokenArray_From_String)

// #endregion

// #region --- token object jagged array ---

const TokenJaggedArray_From_TokenArray = Schema.transform(
  Schema.Array(OneToken),
  Schema.Array(Schema.Array(OneToken)),
  {
    strict: true,
    decode: (array) => {
      const streamArray = Stream.fromIterable(array)
      const scannedStream = streamArray.pipe(
        Stream.scan(
          [] as Array<typeof OneToken>,
          (a: [] | Array<typeof OneToken>, b: any) => { // TODO: <= OneToken
            if (a.length === 0) {
              const c = []
              c.push(b)
              return c
            } else {
              const last: any = a[a.length - 1] // TODO: OneToken
              if (last.token_type === TokenType.literals["0"]) {
                return [b]
              } else {
                if (last.token_type === b.token_type) {
                  const c = [...a]
                  c.push(b)
                  return c
                } else {
                  return [b]
                }
              }
            }
          }
        )
      )
      const scannedChunk = Effect.runSync(Stream.run(
        scannedStream,
        Sink.collectAll()
      ))

      const jaggedStream = Stream.fromIterable(scannedChunk).pipe(
        Stream.runFold(
          [] as any, // TODO: <= OneToken[]
          (a, b) => {
            if (a.length === 0) {
              if (b.length === 0) {
                return []
              } else {
                const c = []
                c.push(b)
                return c
              }
            } else {
              const last = a[a.length - 1]
              if (last[0].token_type === b[0].token_type) {
                const c = [...a]
                c[c.length - 1] = b
                return c
              } else {
                const c = [...a]
                c.push(b)
                return c
              }
            }
          }
        )
      )
      const jaggedChunk = Effect.runSync(Stream.run(
        jaggedStream,
        Sink.collectAll()
      ))

      const resultArray = Chunk.toArray(jaggedChunk)
      return resultArray[0]
    },
    encode: (jagged_array) => jagged_array.flat()
  }
)
const decode_TokenJaggedArray = Schema.decodeSync(TokenJaggedArray_From_TokenArray)
const encode_TokenJaggedArray = Schema.encodeUnknownSync(TokenJaggedArray_From_TokenArray)

// #endregion

// #region --- operand object array ---

const Operator_演算子 = Schema.Struct({
  operator: Schema.String,
  token_type: Schema.Literal(TokenType.literals["0"]),
  token_array: Schema.Array(OneToken)
})
const Operand_数字 = Schema.Struct({
  number: Schema.Number,
  token_type: Schema.Literal(TokenType.literals["1"]),
  token_array: Schema.Array(OneToken)
})
const Operand_変数 = Schema.Struct({
  name: Schema.String,
  token_type: Schema.Literal(TokenType.literals["2"]),
  token_array: Schema.Array(OneToken)
})

const OpItem_From_TokenArray = Schema.transform(
  Schema.Array(OneToken),
  Schema.Union(Operator_演算子, Operand_数字, Operand_変数),
  {
    strict: true,
    decode: (array) => {
      switch (array[0].token_type) {
        case TokenType.literals["0"]:
          return {
            operator: array[0].character,
            token_type: array[0].token_type,
            token_array: array
          }

        case TokenType.literals["1"]: {
          const total = array.reduce((p, c, ci) => {
            const digit = Math.pow(10, array.length - ci - 1)
            const value = digit * Number(c.character)
            return p + value
          }, 0)
          return {
            number: total,
            token_type: array[0].token_type,
            token_array: array
          }
        }

        case TokenType.literals["2"]: {
          const text = array.reduce((p, c) => p + c.character, "")
          return {
            name: text,
            token_type: array[0].token_type,
            token_array: array
          }
        }
      }
    },
    encode: (op_item) => op_item.token_array
  }
)
const decode_OpItem = Schema.decodeSync(OpItem_From_TokenArray)
const encode_OpItem = Schema.encodeUnknown(OpItem_From_TokenArray)

const OpArray_From_TokenJaggedArray = Schema.transform(
  Schema.Array(Schema.Array(OneToken)),
  Schema.Array(Schema.Union(Operator_演算子, Operand_数字, Operand_変数)),
  {
    strict: true,
    decode: (jagged_array) => {
      const resultArray = jagged_array.map((array) => decode_OpItem(array))
      return resultArray
    },
    encode: (op_array) => {
      const result = op_array.map((op_item) => Effect.runSync(encode_OpItem(op_item)))
      return result
    }
  }
)
const decode_OpArray = Schema.decodeSync(OpArray_From_TokenJaggedArray)
const encode_OpArray = Schema.encodeUnknownSync(OpArray_From_TokenJaggedArray)

// #endregion

// #region --- expression object array ---

interface interface_Expression_式 {
  operator: typeof Operator_演算子.Type
  left: interface_Expression_式 | typeof Operand_数字.Type | typeof Operand_変数.Type
  right: interface_Expression_式 | typeof Operand_数字.Type | typeof Operand_変数.Type
  Tag: string
}

const expressionType = Schema.Union(
  Schema.suspend((): Schema.Schema<interface_Expression_式> => Expression_式),
  Operand_数字,
  Operand_変数
)

const Expression_式 = Schema.Struct({
  operator: Operator_演算子,
  left: expressionType,
  right: expressionType,
  Tag: Schema.String
})

const getOpArray = (expression: interface_Expression_式) => {
  const left: any = "Tag" in expression["left"] ? getOpArray(expression["left"]) : [expression["left"]]
  const right: any = "Tag" in expression["right"] ? getOpArray(expression["right"]) : [expression["right"]]
  return [...left, expression["operator"], ...right]
}

const Expression_From_OpArray_中置記法 = Schema.transformOrFail(
  Schema.Array(Schema.Union(Operator_演算子, Operand_数字, Operand_変数)),
  Expression_式,
  {
    strict: true,
    decode: (array, _, ast) => {
      const streamArray = Stream.fromIterable(array)
      const resultStreamEffect = streamArray.pipe(
        Stream.runFoldEffect(
          [] as any, // TODO: <= Expression_式[]
          (a, b) =>
            Effect.gen(function*() {
              if (a.length === 0) {
                if (b.token_type === TokenType.literals["0"]) {
                  return yield* ParseResult.fail(
                    new ParseResult.Type(ast, "演算子の位置が不正です - leftの位置にあります")
                  )
                } else {
                  const c = []
                  c.push(b)
                  return yield* ParseResult.succeed(c)
                }
              } else if (a.length === 1) {
                if (b.token_type === TokenType.literals["0"]) {
                  const c = [...a]
                  c.push(b)
                  return yield* ParseResult.succeed(c)
                } else {
                  return yield* ParseResult.fail(
                    new ParseResult.Type(ast, "演算子以外の位置が不正です - centerの位置にあります")
                  )
                }
              } else if (a.length === 2) {
                if (b.token_type === TokenType.literals["0"]) {
                  return yield* ParseResult.fail(
                    new ParseResult.Type(ast, "演算子の位置が不正です - rightの位置にあります")
                  )
                } else {
                  const c = []
                  const e = {
                    operator: a[1],
                    left: a[0],
                    right: b,
                    Tag: "Expression_式"
                  }
                  c.push(e)
                  return yield* ParseResult.succeed(c)
                }
              } else {
                return yield* ParseResult.fail(new ParseResult.Type(ast, "処理が間違っています"))
              }
            })
        )
      )
      const result = Effect.runSyncExit(resultStreamEffect).pipe(
        Exit.match({
          onSuccess: (value) =>
            value.length === 1
              ? ParseResult.succeed(value[0])
              : ParseResult.fail(new ParseResult.Type(ast, "式が完了しませんでした")),
          onFailure: (_) => ParseResult.fail(new ParseResult.Type(ast, "処理が間違っています"))
        })
      )
      return result
    },
    encode: (expression) => {
      const result = getOpArray(expression)
      return ParseResult.succeed(result)
    }
  }
)
const decode_Expression_Array_中置記法 = Schema.decodeUnknownSync(Expression_From_OpArray_中置記法 as any) // TODO: <= ?
const encode_Expression_Array_中置記法 = Schema.encodeUnknownSync(Expression_From_OpArray_中置記法 as any) // TODO: <= ?

// #endregion

// #region --- get value ---

// type getValueType = (parameter: { [key: string]: number }) => number

const getFunction_FromOperand = (operand: typeof Operand_数字.Type | typeof Operand_変数.Type) => {
  if ("number" in operand) {
    return () => operand.number
  } else if ("name" in operand) {
    return (parameter: { [operand.name]: number }) => parameter[operand.name]
  }
}

const getFunction_FromExpression = (expression: interface_Expression_式) => {
  const leftFunction: any = "Tag" in expression.left // TODO: <= getValueType
    ? getFunction_FromExpression(expression.left) // TODO: <= getValueType
    : getFunction_FromOperand(expression.left)
  const rightFunction: any = "Tag" in expression.right
    ? getFunction_FromExpression(expression.right)
    : getFunction_FromOperand(expression.right)
  switch (expression.operator.operator) {
    case TokenType_演算子.literals["0"]:
    case TokenType_演算子.literals["2"]: {
      return (parameter: { [key: string]: number }) => {
        return leftFunction(parameter) + rightFunction(parameter)
      }
    }
    case TokenType_演算子.literals["1"]:
    case TokenType_演算子.literals["3"]: {
      return (parameter: { [key: string]: number }) => {
        return leftFunction(parameter) - rightFunction(parameter)
      }
    }
  }

  throw Error("演算子の計算で想定外の動作が発生しました")
}
// #endregion

// --- main decode ---
const text = "売上高-売上原価+123"
const data_2025 = {
  "記録年": 2025,
  "売上高": 111000,
  "売上原価": 1234
}

Effect.runSync(Effect.log("--- main decode ---"))

const decode_result_1 = decode_TokenArray(text)
Effect.runSync(Effect.log(decode_result_1))

const decode_result_2 = decode_TokenJaggedArray(decode_result_1)
Effect.runSync(Effect.log(decode_result_2))

const decode_result_3 = decode_OpArray(decode_result_2)
Effect.runSync(Effect.log(decode_result_3))

const decode_result_4 = decode_Expression_Array_中置記法(decode_result_3)
Effect.runSync(Effect.log(decode_result_4))

const result_5_function = getFunction_FromExpression(decode_result_4 as any)
const result_6_value = result_5_function(data_2025)
Effect.runSync(Effect.log(result_6_value))

// --- main encode ---

const Operand_売上高: typeof Operand_変数.Type = {
  name: "売上高",
  token_type: TokenType.literals["2"],
  token_array: [
    {
      character: "売",
      token_type: TokenType.literals["2"]
    },
    {
      character: "上",
      token_type: TokenType.literals["2"]
    },
    {
      character: "高",
      token_type: TokenType.literals["2"]
    }
  ]
}
const Operand_売上原価: typeof Operand_変数.Type = {
  name: "売上原価",
  token_type: TokenType.literals["2"],
  token_array: [
    {
      character: "売",
      token_type: TokenType.literals["2"]
    },
    {
      character: "上",
      token_type: TokenType.literals["2"]
    },
    {
      character: "原",
      token_type: TokenType.literals["2"]
    },
    {
      character: "価",
      token_type: TokenType.literals["2"]
    }
  ]
}
const operator_add: typeof Operator_演算子.Type = {
  operator: "+",
  token_type: TokenType.literals["0"],
  token_array: [
    {
      character: "+",
      token_type: TokenType.literals["0"]
    }
  ]
}
const operator_subtract: typeof Operator_演算子.Type = {
  operator: "-",
  token_type: TokenType.literals["0"],
  token_array: [
    {
      character: "-",
      token_type: TokenType.literals["0"]
    }
  ]
}
const Tag = "Expression_式"
const left: interface_Expression_式 = {
  operator: operator_subtract,
  left: Operand_売上高,
  right: Operand_売上原価,
  Tag
}
const right: typeof Operand_数字.Type = {
  number: 123,
  token_type: TokenType.literals["1"],
  token_array: [
    {
      character: "1",
      token_type: TokenType.literals["1"]
    },
    {
      character: "2",
      token_type: TokenType.literals["1"]
    },
    {
      character: "3",
      token_type: TokenType.literals["1"]
    }
  ]
}
const expression: interface_Expression_式 = {
  operator: operator_add,
  left,
  right,
  Tag
}

Effect.runSync(Effect.log("--- main encode ---"))

const encode_result_1 = encode_Expression_Array_中置記法(expression)
Effect.runSync(Effect.log(encode_result_1))

const encode_result_2 = encode_OpArray(encode_result_1)
Effect.runSync(Effect.log(encode_result_2))

const encode_result_3 = encode_TokenJaggedArray(encode_result_2)
Effect.runSync(Effect.log(encode_result_3))

const encode_result_4 = encode_TokenArray(encode_result_3)
Effect.runSync(Effect.log(encode_result_4))

実行結果

timestamp=2025-10-12T04:11:31.581Z level=INFO fiber=#0 message="--- main decode ---"
timestamp=2025-10-12T04:11:31.603Z level=INFO fiber=#1 message="[
  {
    \"character\": \"売\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"上\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"高\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"-\",
    \"token_type\": \"演算子\"
  },
  {
    \"character\": \"売\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"上\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"原\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"価\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"+\",
    \"token_type\": \"演算子\"
  },
  {
    \"character\": \"1\",
    \"token_type\": \"数字\"
  },
  {
    \"character\": \"2\",
    \"token_type\": \"数字\"
  },
  {
    \"character\": \"3\",
    \"token_type\": \"数字\"
  }
]"
timestamp=2025-10-12T04:11:31.639Z level=INFO fiber=#7 message="[
  [
    {
      \"character\": \"売\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"上\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"高\",
      \"token_type\": \"変数\"
    }
  ],
  [
    {
      \"character\": \"-\",
      \"token_type\": \"演算子\"
    }
  ],
  [
    {
      \"character\": \"売\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"上\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"原\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"価\",
      \"token_type\": \"変数\"
    }
  ],
  [
    {
      \"character\": \"+\",
      \"token_type\": \"演算子\"
    }
  ],
  [
    {
      \"character\": \"1\",
      \"token_type\": \"数字\"
    },
    {
      \"character\": \"2\",
      \"token_type\": \"数字\"
    },
    {
      \"character\": \"3\",
      \"token_type\": \"数字\"
    }
  ]
]"
timestamp=2025-10-12T04:11:31.641Z level=INFO fiber=#8 message="[
  {
    \"name\": \"売上高\",
    \"token_type\": \"変数\",
    \"token_array\": [
      {
        \"character\": \"売\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"上\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"高\",
        \"token_type\": \"変数\"
      }
    ]
  },
  {
    \"operator\": \"-\",
    \"token_type\": \"演算子\",
    \"token_array\": [
      {
        \"character\": \"-\",
        \"token_type\": \"演算子\"
      }
    ]
  },
  {
    \"name\": \"売上原価\",
    \"token_type\": \"変数\",
    \"token_array\": [
      {
        \"character\": \"売\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"上\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"原\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"価\",
        \"token_type\": \"変数\"
      }
    ]
  },
  {
    \"operator\": \"+\",
    \"token_type\": \"演算子\",
    \"token_array\": [
      {
        \"character\": \"+\",
        \"token_type\": \"演算子\"
      }
    ]
  },
  {
    \"number\": 123,
    \"token_type\": \"数字\",
    \"token_array\": [
      {
        \"character\": \"1\",
        \"token_type\": \"数字\"
      },
      {
        \"character\": \"2\",
        \"token_type\": \"数字\"
      },
      {
        \"character\": \"3\",
        \"token_type\": \"数字\"
      }
    ]
  }
]"
timestamp=2025-10-12T04:11:31.647Z level=INFO fiber=#11 message="{
  \"operator\": {
    \"operator\": \"+\",
    \"token_type\": \"演算子\",
    \"token_array\": [
      {
        \"character\": \"+\",
        \"token_type\": \"演算子\"
      }
    ]
  },
  \"left\": {
    \"operator\": {
      \"operator\": \"-\",
      \"token_type\": \"演算子\",
      \"token_array\": [
        {
          \"character\": \"-\",
          \"token_type\": \"演算子\"
        }
      ]
    },
    \"left\": {
      \"name\": \"売上高\",
      \"token_type\": \"変数\",
      \"token_array\": [
        {
          \"character\": \"売\",
          \"token_type\": \"変数\"
        },
        {
          \"character\": \"上\",
          \"token_type\": \"変数\"
        },
        {
          \"character\": \"高\",
          \"token_type\": \"変数\"
        }
      ]
    },
    \"right\": {
      \"name\": \"売上原価\",
      \"token_type\": \"変数\",
      \"token_array\": [
        {
          \"character\": \"売\",
          \"token_type\": \"変数\"
        },
        {
          \"character\": \"上\",
          \"token_type\": \"変数\"
        },
        {
          \"character\": \"原\",
          \"token_type\": \"変数\"
        },
        {
          \"character\": \"価\",
          \"token_type\": \"変数\"
        }
      ]
    },
    \"Tag\": \"Expression_式\"
  },
  \"right\": {
    \"number\": 123,
    \"token_type\": \"数字\",
    \"token_array\": [
      {
        \"character\": \"1\",
        \"token_type\": \"数字\"
      },
      {
        \"character\": \"2\",
        \"token_type\": \"数字\"
      },
      {
        \"character\": \"3\",
        \"token_type\": \"数字\"
      }
    ]
  },
  \"Tag\": \"Expression_式\"
}"
timestamp=2025-10-12T04:11:31.649Z level=INFO fiber=#12 message=109889
timestamp=2025-10-12T04:11:31.650Z level=INFO fiber=#13 message="--- main encode ---"
timestamp=2025-10-12T04:11:31.652Z level=INFO fiber=#14 message="[
  {
    \"name\": \"売上高\",
    \"token_type\": \"変数\",
    \"token_array\": [
      {
        \"character\": \"売\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"上\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"高\",
        \"token_type\": \"変数\"
      }
    ]
  },
  {
    \"operator\": \"-\",
    \"token_type\": \"演算子\",
    \"token_array\": [
      {
        \"character\": \"-\",
        \"token_type\": \"演算子\"
      }
    ]
  },
  {
    \"name\": \"売上原価\",
    \"token_type\": \"変数\",
    \"token_array\": [
      {
        \"character\": \"売\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"上\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"原\",
        \"token_type\": \"変数\"
      },
      {
        \"character\": \"価\",
        \"token_type\": \"変数\"
      }
    ]
  },
  {
    \"operator\": \"+\",
    \"token_type\": \"演算子\",
    \"token_array\": [
      {
        \"character\": \"+\",
        \"token_type\": \"演算子\"
      }
    ]
  },
  {
    \"number\": 123,
    \"token_type\": \"数字\",
    \"token_array\": [
      {
        \"character\": \"1\",
        \"token_type\": \"数字\"
      },
      {
        \"character\": \"2\",
        \"token_type\": \"数字\"
      },
      {
        \"character\": \"3\",
        \"token_type\": \"数字\"
      }
    ]
  }
]"
timestamp=2025-10-12T04:11:31.654Z level=INFO fiber=#15 message="[
  [
    {
      \"character\": \"売\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"上\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"高\",
      \"token_type\": \"変数\"
    }
  ],
  [
    {
      \"character\": \"-\",
      \"token_type\": \"演算子\"
    }
  ],
  [
    {
      \"character\": \"売\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"上\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"原\",
      \"token_type\": \"変数\"
    },
    {
      \"character\": \"価\",
      \"token_type\": \"変数\"
    }
  ],
  [
    {
      \"character\": \"+\",
      \"token_type\": \"演算子\"
    }
  ],
  [
    {
      \"character\": \"1\",
      \"token_type\": \"数字\"
    },
    {
      \"character\": \"2\",
      \"token_type\": \"数字\"
    },
    {
      \"character\": \"3\",
      \"token_type\": \"数字\"
    }
  ]
]"
timestamp=2025-10-12T04:11:31.656Z level=INFO fiber=#16 message="[
  {
    \"character\": \"売\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"上\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"高\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"-\",
    \"token_type\": \"演算子\"
  },
  {
    \"character\": \"売\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"上\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"原\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"価\",
    \"token_type\": \"変数\"
  },
  {
    \"character\": \"+\",
    \"token_type\": \"演算子\"
  },
  {
    \"character\": \"1\",
    \"token_type\": \"数字\"
  },
  {
    \"character\": \"2\",
    \"token_type\": \"数字\"
  },
  {
    \"character\": \"3\",
    \"token_type\": \"数字\"
  }
]"
timestamp=2025-10-12T04:11:31.657Z level=INFO fiber=#17 message=売上高-売上原価+123

計算指示から計算結果を取得するところ

decodeの個所がテキスト電文から計算オブジェクトを作成している
getFunction_FromExpression　で　計算用の関数を生成し、
その関数にサーバデータをいれることで計算を実施している

const result_5_function = getFunction_FromExpression(decode_result_4 as any)
const result_6_value = result_5_function(data_2025)
Effect.runSync(Effect.log(result_6_value))
0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?