Início / user-1100107

Stéphane Laurent's questions

Martin Hope
Stéphane Laurent
Asked: 2023-12-17 01:21:12 +0800 CST
  • 9

Dada uma expressão aritmétrica, por exemplo x + y*z, quero convertê-la para add(x, multiply(y, z)).

Encontrei uma função útil aqui :

> getAST <- function(ee) purrr::map_if(as.list(ee), is.call, getAST)
> getAST(quote(x + y*z)) 
[[1]]
`+`

[[2]]
x

[[3]]
[[3]][[1]]
`*`

[[3]][[2]]
y

[[3]][[3]]
z

Pode-se usar rapply(result, as.character, how = "list")para obter caracteres em vez de símbolos.

Como obter add(x, multiply(y, z))deste AST (o resultado)? Isso se torna mais complicado quando há alguns parênteses:

> getAST(quote((x + y) * z)) 
[[1]]
`*`

[[2]]
[[2]][[1]]
`(`

[[2]][[2]]
[[2]][[2]][[1]]
`+`

[[2]][[2]][[2]]
x

[[2]][[2]][[3]]
y



[[3]]
z

Não exijo a resposta, devo usar a getASTfunção. É apenas um caminho possível a seguir.

É claro que no meu caso de uso real as expressões são mais longas.

Aqui está uma solução (eu acho) para o caso em que não há parênteses:

getAST <- function(ee) purrr::map_if(as.list(ee), is.call, getAST)

ast <- rapply(getAST(quote(x + y*z)), as.character, how = "list")

convertAST <- function(ast) {
  op <- switch(
    ast[[1]],
    "+" = "add",
    "-" = "subtract",
    "*" = "multiply",
    "/" = "divide"
  )
  left <- ast[[2]]
  right <- ast[[3]]
  if(is.character(left) && is.character(right)) {
    return(sprintf("%s(%s, %s)", op, left, right))
  }
  if(is.character(left)) {
    return(sprintf("%s(%s, %s)", op, left, convertAST(right)))
  }
  if(is.character(right)) {
    return(sprintf("%s(%s, %s)", op, convertAST(left), right))
  }
  return(sprintf("%s(%s, %s)", op, convertAST(left), convertAST(right)))
}

convertAST(ast)
Martin Hope
Stéphane Laurent
Asked: 2023-08-18 01:20:26 +0800 CST
  • 6

Em JavaScript:

console.log(13 % 5);
// Expected output: 3

console.log(-13 % 5);
// Expected output: -3

Eu preciso do mesmo em Haskell. Eu fiz

:{
modulo :: Double -> Int -> Double
modulo a p = 
    let p' = fromIntegral p
    in
    if a > 0 
        then a - fromIntegral(p * floor(a/p'))  
        else a - fromIntegral(p * ceiling(a/p'))
:}

Isso parece funcionar (pelo menos encontro os mesmos resultados que os do JavaScript). Existe uma maneira melhor?

Ao contrário de rem, deve funcionar para Double a:

ghci> modulo (-13.5) 5
-3.5
haskell